Class AeSdkBase

Basic AeSdk class implements:

node selector,
integrated compiler support,
wrappers of account methods mapped to the current account.

Hierarchy

AeSdkMethods
- AeSdkBase
  - AeSdk
  - AeSdkAepp

Index

Constructors

constructor

new AeSdkBase(options?: AeSdkMethodsOptions & {
    nodes?: {
        instance: Node;
        name: string;
    }[];
}): AeSdkBase
Parameters
- options: AeSdkMethodsOptions & {
      nodes?: {
          instance: Node;
          name: string;
      }[];
  } = {}
  
  Options
Returns AeSdkBase
Overrides AeSdkMethods.constructor
- Defined in AeSdkBase.ts:25

Properties

_getPollInterval

_getPollInterval: ((...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => number)

Type declaration

- (...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): number
- Parameters
  - Rest ...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns number

_options

_options: AeSdkMethodsOptions = ...

aensBid

aensBid: ((...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<AensClaimReturnType>)

Type declaration

- (...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<AensClaimReturnType>
- Parameters
  - Rest ...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<AensClaimReturnType>

aensClaim

aensClaim: ((...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<AensClaimReturnType>)

Type declaration

- (...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<AensClaimReturnType>
- Parameters
  - Rest ...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<AensClaimReturnType>

aensPreclaim

aensPreclaim: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<SendReturnType & {
    claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
    commitmentId: string;
    height: number;
    salt: number;
}>>)

Type declaration

- (...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<Readonly<SendReturnType & {
      claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
      commitmentId: string;
      height: number;
      salt: number;
  }>>
- Parameters
  - Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<Readonly<SendReturnType & {
      claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
      commitmentId: string;
      height: number;
      salt: number;
  }>>

aensQuery

aensQuery: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
    onNode: Node;
} & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<{
    id: string;
    owner?: string;
    pointers: ({ key: string; id: string; })[];
    ttl: number;
} & {
    extendTtl: ((nameTtl: number, options?: Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
    id: `nm_${string}`;
    owner: `ak_${string}`;
    pointers: NamePointer[] | KeyPointers;
    revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: AccountBase;
    }) => Promise<SendReturnType>);
    transfer: ((account: `ak_${string}`, options?: {
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
    ttl: number;
    update: ((pointers: KeyPointers, options?: Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: AccountBase;
    }) => Promise<SendReturnType> & Promise<Readonly<{
        id: string;
        owner?: string;
        pointers: ({ key: string; id: string; })[];
        ttl: number;
    } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
}>>)

Type declaration

- (...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
      onNode: Node;
  } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<Readonly<{
      id: string;
      owner?: string;
      pointers: ({ key: string; id: string; })[];
      ttl: number;
  } & {
      extendTtl: ((nameTtl: number, options?: Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      id: `nm_${string}`;
      owner: `ak_${string}`;
      pointers: NamePointer[] | KeyPointers;
      revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: AccountBase;
      }) => Promise<SendReturnType>);
      transfer: ((account: `ak_${string}`, options?: {
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      ttl: number;
      update: ((pointers: KeyPointers, options?: Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: AccountBase;
      }) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
  }>>
- Parameters
  - Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
        onNode: Node;
    } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<Readonly<{
      id: string;
      owner?: string;
      pointers: ({ key: string; id: string; })[];
      ttl: number;
  } & {
      extendTtl: ((nameTtl: number, options?: Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler">) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      id: `nm_${string}`;
      owner: `ak_${string}`;
      pointers: NamePointer[] | KeyPointers;
      revoke: ((options?: Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: AccountBase;
      }) => Promise<SendReturnType>);
      transfer: ((account: `ak_${string}`, options?: {
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
      ttl: number;
      update: ((pointers: KeyPointers, options?: Omit<{
          onNode: Node;
      } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
          onAccount?: AccountBase;
      }) => Promise<SendReturnType> & Promise<Readonly<{
          id: string;
          owner?: string;
          pointers: ({ key: string; id: string; })[];
          ttl: number;
      } & ({ id: `nm_${string}`; owner: `ak_${string}`; pointers: NamePointer[] | KeyPointers; ttl: number; update: (pointers: KeyPointers, options?: (Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | ... 1 more ... | "onCompiler"> & { ...; }) | undefined) => Promise<...> & Promise<...>; transfer: (a...)>>);
  }>>

aensRevoke

aensRevoke: ((...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

aensTransfer

aensTransfer: ((...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

aensUpdate

aensUpdate: ((...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

awaitHeight

awaitHeight: ((...args: [number] | [number, Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

- (...args: [number] | [number, Omit<{
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<number>
- Parameters
  - Rest ...args: [number] | [number, Omit<{
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<number>

buildAuthTxHash

buildAuthTxHash: ((...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Uint8Array>)

Type declaration

- (...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<Uint8Array>
- Parameters
  - Rest ...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<Uint8Array>

createGeneralizedAccount

createGeneralizedAccount: ((...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<Readonly<{
    gaContractId: `ct_${string}`;
    owner: `ak_${string}`;
    rawTx: `tx_${string}`;
    transaction: `th_${string}`;
}>>)

Type declaration

- (...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<Readonly<{
      gaContractId: `ct_${string}`;
      owner: `ak_${string}`;
      rawTx: `tx_${string}`;
      transaction: `th_${string}`;
  }>>
- Parameters
  - Rest ...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<Readonly<{
      gaContractId: `ct_${string}`;
      owner: `ak_${string}`;
      rawTx: `tx_${string}`;
      transaction: `th_${string}`;
  }>>

extendOracleTtl

extendOracleTtl: ((...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType & GetOracleObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType & GetOracleObjectReturnType>

getAccount

getAccount: ((...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
    hash?: `kh_${string}` | `mh_${string}`;
    height?: number;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    authFun?: string;
    balance: bigint;
    contractId?: string;
    id: string;
    kind?: AccountKind;
    nonce: number;
    payable?: boolean;
}>)

Type declaration

- (...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
      hash?: `kh_${string}` | `mh_${string}`;
      height?: number;
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      authFun?: string;
      balance: bigint;
      contractId?: string;
      id: string;
      kind?: AccountKind;
      nonce: number;
      payable?: boolean;
  }>
- Parameters
  - Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
        hash?: `kh_${string}` | `mh_${string}`;
        height?: number;
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      authFun?: string;
      balance: bigint;
      contractId?: string;
      id: string;
      kind?: AccountKind;
      nonce: number;
      payable?: boolean;
  }>

getBalance

getBalance: ((...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
    format?: AE_AMOUNT_FORMATS;
} & {
    hash?: `kh_${string}` | `mh_${string}`;
    height?: number;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<string>)

Type declaration

- (...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
      format?: AE_AMOUNT_FORMATS;
  } & {
      hash?: `kh_${string}` | `mh_${string}`;
      height?: number;
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<string>
- Parameters
  - Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
        format?: AE_AMOUNT_FORMATS;
    } & {
        hash?: `kh_${string}` | `mh_${string}`;
        height?: number;
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<string>

getContract

getContract: ((...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    abiVersion: string;
    active: boolean;
    deposit: bigint;
    id: string;
    ownerId: string;
    referrerIds: string[];
    vmVersion: string;
}>)

Type declaration

- (...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      abiVersion: string;
      active: boolean;
      deposit: bigint;
      id: string;
      ownerId: string;
      referrerIds: string[];
      vmVersion: string;
  }>
- Parameters
  - Rest ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      abiVersion: string;
      active: boolean;
      deposit: bigint;
      id: string;
      ownerId: string;
      referrerIds: string[];
      vmVersion: string;
  }>

getContractByteCode

getContractByteCode: ((...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    bytecode: `cb_${string}`;
}>)

Type declaration

- (...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      bytecode: `cb_${string}`;
  }>
- Parameters
  - Rest ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
  bytecode: `cb_${string}`;
  }>

getCurrentGeneration

getCurrentGeneration: ((...args: [] | [Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
    microBlocks: string[];
}>)

Type declaration

- (...args: [] | [Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
      microBlocks: string[];
  }>
- Parameters
  - Rest ...args: [] | [Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
  keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
  microBlocks: string[];
  }>

getGeneration

getGeneration: ((...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
    microBlocks: string[];
}>)

Type declaration

- (...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
      microBlocks: string[];
  }>
- Parameters
  - Rest ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
  keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
  microBlocks: string[];
  }>

getHeight

getHeight: ((...args: [] | [Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

- (...args: [] | [Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<number>
- Parameters
  - Rest ...args: [] | [Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<number>

getKeyBlock

getKeyBlock: ((...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    beneficiary: string;
    hash: string;
    height: number;
    info: string;
    miner: string;
    nonce?: number;
    pow?: string[];
    prevHash: string;
    prevKeyHash: string;
    stateHash: string;
    target: string;
    time: number;
    version: number;
}>)

Type declaration

- (...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      beneficiary: string;
      hash: string;
      height: number;
      info: string;
      miner: string;
      nonce?: number;
      pow?: string[];
      prevHash: string;
      prevKeyHash: string;
      stateHash: string;
      target: string;
      time: number;
      version: number;
  }>
- Parameters
  - Rest ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      beneficiary: string;
      hash: string;
      height: number;
      info: string;
      miner: string;
      nonce?: number;
      pow?: string[];
      prevHash: string;
      prevKeyHash: string;
      stateHash: string;
      target: string;
      time: number;
      version: number;
  }>

getMicroBlockHeader

getMicroBlockHeader: ((...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    hash: string;
    height: number;
    pofHash: string;
    prevHash: string;
    prevKeyHash: string;
    signature: string;
    stateHash: string;
    time: number;
    txsHash: string;
    version: number;
}>)

Type declaration

- (...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      hash: string;
      height: number;
      pofHash: string;
      prevHash: string;
      prevKeyHash: string;
      signature: string;
      stateHash: string;
      time: number;
      txsHash: string;
      version: number;
  }>
- Parameters
  - Rest ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      hash: string;
      height: number;
      pofHash: string;
      prevHash: string;
      prevKeyHash: string;
      signature: string;
      stateHash: string;
      time: number;
      txsHash: string;
      version: number;
  }>

getMicroBlockTransactions

getMicroBlockTransactions: ((...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    blockHash: string;
    blockHeight: number;
    hash: string;
    signatures: string[];
    tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
}[]>)

Type declaration

- (...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      blockHash: string;
      blockHeight: number;
      hash: string;
      signatures: string[];
      tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
  }[]>
- Parameters
  - Rest ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      blockHash: string;
      blockHeight: number;
      hash: string;
      signatures: string[];
      tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
  }[]>

getName

getName: ((...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    id: string;
    owner?: string;
    pointers: ({ key: string; id: string; })[];
    ttl: number;
}>)

Type declaration

- (...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      id: string;
      owner?: string;
      pointers: ({ key: string; id: string; })[];
      ttl: number;
  }>
- Parameters
  - Rest ...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      id: string;
      owner?: string;
      pointers: ({ key: string; id: string; })[];
      ttl: number;
  }>

getOracleObject

getOracleObject: ((...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
    onAccount: AccountBase;
    onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<GetOracleObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
      onAccount: AccountBase;
      onNode: Node;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<GetOracleObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
        onAccount: AccountBase;
        onNode: Node;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<GetOracleObjectReturnType>

getQueryObject

getQueryObject: ((...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<GetQueryObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<GetQueryObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<RespondToQueryOptions & {
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<GetQueryObjectReturnType>

payForTransaction

payForTransaction: ((...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

poll

poll: ((...args: [`th_${string}`] | [`th_${string}`, Omit<{
    blocks?: number;
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    blockHash: string;
    blockHeight: number;
    hash: string;
    signatures: string[];
    tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
}>)

Type declaration

- (...args: [`th_${string}`] | [`th_${string}`, Omit<{
      blocks?: number;
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      blockHash: string;
      blockHeight: number;
      hash: string;
      signatures: string[];
      tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
  }>
- Parameters
  - Rest ...args: [`th_${string}`] | [`th_${string}`, Omit<{
        blocks?: number;
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      blockHash: string;
      blockHeight: number;
      hash: string;
      signatures: string[];
      tx: { type: "Tx"; recipientId?: string | undefined; amount?: bigint | undefined; fee: bigint; ttl?: number | undefined; senderId?: string | undefined; nonce?: number | undefined; payload?: string | undefined; ... 53 more ...; version: number; };
  }>

pollForQueries

pollForQueries: ((...args: [`ok_${string}`, ((queries: {
    fee: bigint;
    id: string;
    oracleId: string;
    query: string;
    response: string;
    responseTtl: { type: TTLType; value: string; };
    senderId: string;
    senderNonce: string;
    ttl: number;
}[]) => void)] | [`ok_${string}`, ((queries: {
    fee: bigint;
    id: string;
    oracleId: string;
    query: string;
    response: string;
    responseTtl: { type: TTLType; value: string; };
    senderId: string;
    senderNonce: string;
    ttl: number;
}[]) => void), Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => (() => void))

Type declaration

- (...args: [`ok_${string}`, ((queries: {
      fee: bigint;
      id: string;
      oracleId: string;
      query: string;
      response: string;
      responseTtl: { type: TTLType; value: string; };
      senderId: string;
      senderNonce: string;
      ttl: number;
  }[]) => void)] | [`ok_${string}`, ((queries: {
      fee: bigint;
      id: string;
      oracleId: string;
      query: string;
      response: string;
      responseTtl: { type: TTLType; value: string; };
      senderId: string;
      senderNonce: string;
      ttl: number;
  }[]) => void), Omit<{
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): (() => void)
- Parameters
  - Rest ...args: [`ok_${string}`, ((queries: {
        fee: bigint;
        id: string;
        oracleId: string;
        query: string;
        response: string;
        responseTtl: { type: TTLType; value: string; };
        senderId: string;
        senderNonce: string;
        ttl: number;
    }[]) => void)] | [`ok_${string}`, ((queries: {
        fee: bigint;
        id: string;
        oracleId: string;
        query: string;
        response: string;
        responseTtl: { type: TTLType; value: string; };
        senderId: string;
        senderNonce: string;
        ttl: number;
    }[]) => void), Omit<{
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns (() => void)
  - - (): void
    - Poll for oracle queries
      
      Category
      oracle
      
      Returns
      Callback to stop polling function
      
      Returns void

pollForQueryResponse

pollForQueryResponse: ((...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<string>)

Type declaration

- (...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<string>
- Parameters
  - Rest ...args: [`ok_${string}`, `oq_${string}`] | [`ok_${string}`, `oq_${string}`, Omit<{
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<string>

pool

pool: Map<string, Node> = ...

postQueryToOracle

postQueryToOracle: ((...args: [oracleId: `ok_${string}`, query: string] | [`ok_${string}`, string, Omit<PostQueryToOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetQueryObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`, query: string] | [`ok_${string}`, string, Omit<PostQueryToOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType & GetQueryObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`, query: string] | [`ok_${string}`, string, Omit<PostQueryToOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType & GetQueryObjectReturnType>

registerOracle

registerOracle: ((...args: [queryFormat: string, responseFormat: string] | [string, string, Omit<RegisterOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

- (...args: [queryFormat: string, responseFormat: string] | [string, string, Omit<RegisterOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType & GetOracleObjectReturnType>
- Parameters
  - Rest ...args: [queryFormat: string, responseFormat: string] | [string, string, Omit<RegisterOracleOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType & GetOracleObjectReturnType>

resolveName

resolveName: ((...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
    onNode: Node;
    resolveByNode?: boolean;
    verify?: boolean;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>)

Type declaration

- (...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
      onNode: Node;
      resolveByNode?: boolean;
      verify?: boolean;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>
- Parameters
  - Rest ...args: [`${string}.chain` | `ct_${string}` | `ak_${string}`, string] | [`${string}.chain` | `ct_${string}` | `ak_${string}`, string, Omit<{
        onNode: Node;
        resolveByNode?: boolean;
        verify?: boolean;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<`ct_${string}` | `ak_${string}` | `nm_${string}`>

respondToQuery

respondToQuery: ((...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`, response: string] | [`ok_${string}`, `oq_${string}`, string, Omit<RespondToQueryOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType & GetOracleObjectReturnType>)

Type declaration

- (...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`, response: string] | [`ok_${string}`, `oq_${string}`, string, Omit<RespondToQueryOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType & GetOracleObjectReturnType>
- Parameters
  - Rest ...args: [oracleId: `ok_${string}`, queryId: `oq_${string}`, response: string] | [`ok_${string}`, `oq_${string}`, string, Omit<RespondToQueryOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType & GetOracleObjectReturnType>

`Optional` selectedNodeName

selectedNodeName?: string

send

send: ((...args: [tx: `tx_${string}`] | [`tx_${string}`, Omit<SendOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [tx: `tx_${string}`] | [`tx_${string}`, Omit<SendOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [tx: `tx_${string}`] | [`tx_${string}`, Omit<SendOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

sendTransaction

sendTransaction: ((...args: [`tx_${string}`] | [`tx_${string}`, Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendTransactionReturnType>)

Type declaration

- (...args: [`tx_${string}`] | [`tx_${string}`, Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendTransactionReturnType>
- Parameters
  - Rest ...args: [`tx_${string}`] | [`tx_${string}`, Omit<SendTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendTransactionReturnType>

spend

spend: ((...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [amount: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<SpendOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

transferFunds

transferFunds: ((...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<SendReturnType>)

Type declaration

- (...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<SendReturnType>
- Parameters
  - Rest ...args: [fraction: string | number, recipientIdOrName: `${string}.chain` | `ak_${string}`] | [string | number, `${string}.chain` | `ak_${string}`, Omit<TransferFundsOptions, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<SendReturnType>

txDryRun

txDryRun: ((...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
    combine?: boolean;
    onNode: Node;
    top?: number | `kh_${string}` | `mh_${string}`;
    txEvents?: boolean;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<{
    txEvents?: {}[];
} & {
    callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
    reason?: string;
    result: string;
    type: string;
}>)

Type declaration

- (...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
      combine?: boolean;
      onNode: Node;
      top?: number | `kh_${string}` | `mh_${string}`;
      txEvents?: boolean;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<{
      txEvents?: {}[];
  } & {
      callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
      reason?: string;
      result: string;
      type: string;
  }>
- Parameters
  - Rest ...args: [`tx_${string}`, `ak_${string}`] | [`tx_${string}`, `ak_${string}`, Omit<{
        combine?: boolean;
        onNode: Node;
        top?: number | `kh_${string}` | `mh_${string}`;
        txEvents?: boolean;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<{
      txEvents?: {}[];
  } & {
      callObj?: { callerId: string; callerNonce: string; height: number; contractId: string; gasPrice: bigint; gasUsed: number; log: { address: string; topics: string[]; data: string; }[]; returnValue: string; returnType: ContractCallReturnType; };
      reason?: string;
      result: string;
      type: string;
  }>

waitForTxConfirm

waitForTxConfirm: ((...args: [`th_${string}`] | [`th_${string}`, Omit<{
    confirm?: number;
    onNode: Node;
} & {
    interval?: number;
    onNode: Node;
} & {
    _expectedMineRate?: number;
    _maxPollInterval?: number;
    _microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
    onAccount?: OnAccount;
    onCompiler?: CompilerBase;
    onNode?: Node;
}]) => Promise<number>)

Type declaration

- (...args: [`th_${string}`] | [`th_${string}`, Omit<{
      confirm?: number;
      onNode: Node;
  } & {
      interval?: number;
      onNode: Node;
  } & {
      _expectedMineRate?: number;
      _maxPollInterval?: number;
      _microBlockCycle?: number;
  }, "onNode" | "onAccount" | "onCompiler"> & {
      onAccount?: OnAccount;
      onCompiler?: CompilerBase;
      onNode?: Node;
  }]): Promise<number>
- Parameters
  - Rest ...args: [`th_${string}`] | [`th_${string}`, Omit<{
        confirm?: number;
        onNode: Node;
    } & {
        interval?: number;
        onNode: Node;
    } & {
        _expectedMineRate?: number;
        _maxPollInterval?: number;
        _microBlockCycle?: number;
    }, "onNode" | "onAccount" | "onCompiler"> & {
        onAccount?: OnAccount;
        onCompiler?: CompilerBase;
        onNode?: Node;
    }]
  Returns Promise<number>

Accessors

address

get address(): `ak_${string}`
Returns `ak_${string}`
- Defined in AeSdkBase.ts:130

api

get api(): Node
Returns Node
- Defined in AeSdkBase.ts:45

compilerApi

get compilerApi(): CompilerBase
Returns CompilerBase
- Defined in AeSdkBase.ts:38

Methods

_getOptions

_getOptions(): {
    onAccount: AccountBase;
    onCompiler: CompilerBase;
    onNode: Node;
}
Returns {
    onAccount: AccountBase;
    onCompiler: CompilerBase;
    onNode: Node;
}
- onAccount: AccountBase
- onCompiler: CompilerBase
- onNode: Node
Overrides AeSdkMethods._getOptions
- Defined in AeSdkBase.ts:156

_resolveAccount

_resolveAccount(account?: OnAccount): AccountBase
Resolves an account
Parameters
- Optional account: OnAccount
  
  ak-address, instance of AccountBase, or keypair
Returns AccountBase
Inherited from AeSdkMethods._resolveAccount
- Defined in AeSdkMethods.ts:87

addNode

addNode(name: string, node: Node, select?: boolean): void
Add Node

Example
```
// add and select new node with name 'testNode'
aeSdkBase.addNode('testNode', new Node({ url }), true)
```
Parameters
- name: string
  
  Node name
- node: Node
  
  Node instance
- select: boolean = false
  
  Select this node as current
Returns void
- Defined in AeSdkBase.ts:61

addresses

addresses(): `ak_${string}`[]
Returns `ak_${string}`[]
- Defined in AeSdkBase.ts:126

buildTx

buildTx<TxType>(txType: TxType, options: Omit<Omit<{
    tag: TxType;
    version?: Extract<KeysOfUnion<{
        10: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Account);
                serialize: ((value?: Account) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["balance", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }]];
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Account);
                serialize: ((value?: Account) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["flags", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["balance", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["gaContract", {
                deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["gaAuthFun", binary, ContractBytearray]];
        };
        11: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => SignedTx);
                serialize: ((value?: SignedTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["signatures", signatures], readonly ["encodedTx", rlpBinary]];
        };
        12: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => SpendTx);
                serialize: ((value?: SpendTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["senderId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["recipientId", {
                deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["payload", payload]];
        };
        20: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Oracle);
                serialize: ((value?: Oracle) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["oracleTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["abiVersion", {
                deserialize: ((value: Buffer) => ABI_VERSIONS);
                serialize: ((value: ABI_VERSIONS) => Buffer);
            }]];
        };
        22: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OracleRegisterTx);
                serialize: ((value?: OracleRegisterTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["oracleTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["oracleTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["abiVersion", {
                deserialize: ((value: Buffer) => ABI_VERSIONS);
                serialize: ((value: ABI_VERSIONS) => Buffer);
            }]];
        };
        23: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OracleQueryTx);
                serialize: ((value?: OracleQueryTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["senderId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["oracleId", {
                deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["query", string], readonly ["queryFee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["queryTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["queryTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["responseTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["responseTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        24: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OracleResponseTx);
                serialize: ((value?: OracleResponseTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["oracleId", {
                deserialize: ((value: Buffer) => `ok_${string}`);
                serialize: ((value: `ok_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["queryId", binary, OracleQueryId], readonly ["response", string], readonly ["responseTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["responseTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        25: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OracleExtendTx);
                serialize: ((value?: OracleExtendTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["oracleId", {
                deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["oracleTtlType", {
                deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
            }], readonly ["oracleTtlValue", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        30: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Name);
                serialize: ((value?: Name) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nameTtl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["status", binary], readonly ["clientTtl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["pointers", {
                deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                serialize(pointers: NamePointer[]): Buffer[][];
            }]];
        };
        32: {
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameClaimTx);
                serialize: ((value?: NameClaimTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["name", {
                deserialize(value: Buffer): `${string}.chain`;
                serialize(value: `${string}.chain`): Buffer;
            }], readonly ["nameSalt", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["nameFee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, txFields: {
                    name: `${string}.chain`;
                } & Options): Buffer;
                serializeAettos(_value: undefined | string, txFields: {
                    name: `${string}.chain`;
                }): string;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        33: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NamePreclaimTx);
                serialize: ((value?: NamePreclaimTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["commitmentId", {
                deserialize: ((value: Buffer) => `cm_${string}`);
                serialize: ((value: `cm_${string}`) => Buffer);
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        34: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameUpdateTx);
                serialize: ((value?: NameUpdateTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nameId", {
                deserialize: ((value: Buffer) => `nm_${string}`);
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            }], readonly ["nameTtl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["pointers", {
                deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                serialize(pointers: NamePointer[]): Buffer[][];
            }], readonly ["clientTtl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        35: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameRevokeTx);
                serialize: ((value?: NameRevokeTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nameId", {
                deserialize: ((value: Buffer) => `nm_${string}`);
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        36: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameTransferTx);
                serialize: ((value?: NameTransferTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accountId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nameId", {
                deserialize: ((value: Buffer) => `nm_${string}`);
                serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
            }], readonly ["recipientId", {
                deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        40: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Contract);
                serialize: ((value?: Contract) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["owner", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["log", binary, ContractBytearray], readonly ["active", bool], readonly ["referers", {
                deserialize: ((value: Buffer[]) => `ak_${string}`[]);
                serialize: ((value: `ak_${string}`[]) => Buffer[]);
            }], readonly ["deposit", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, options: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }]];
        };
        41: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ContractCall);
                serialize: ((value?: ContractCall) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["callerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["callerNonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["height", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["contractId", {
                deserialize: ((value: Buffer) => `ct_${string}`);
                serialize: ((value: `ct_${string}`) => Buffer);
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["gasUsed", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["returnValue", binary, ContractBytearray], readonly ["returnType", {
                deserialize: ((value: Buffer) => CallReturnType);
                serialize: ((value: CallReturnType) => Buffer);
            }], readonly ["log", rawBinary]];
        };
        42: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ContractCreateTx);
                serialize: ((value?: ContractCreateTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["ownerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["code", binary, ContractBytearray], readonly ["ctVersion", ctVersion], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["deposit", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, options: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): Buffer;
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["callData", binary, ContractBytearray]];
        };
        43: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ContractCallTx);
                serialize: ((value?: ContractCallTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["callerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["contractId", {
                deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
            }], readonly ["abiVersion", {
                deserialize: ((value: Buffer) => ABI_VERSIONS);
                serialize: ((value: ABI_VERSIONS) => Buffer);
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value: undefined | string): string;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): Buffer;
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["callData", binary, ContractBytearray]];
        };
        50: {
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelCreateTx);
                serialize: ((value?: ChannelCreateTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["initiator", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["initiatorAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["responder", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["responderAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["channelReserve", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["lockPeriod", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["initiatorDelegateIds", string], readonly ["responderDelegateIds", string], readonly ["stateHash", binary, State], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        51: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelDepositTx);
                serialize: ((value?: ChannelDepositTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["stateHash", binary, State], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        52: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelWithdrawTx);
                serialize: ((value?: ChannelWithdrawTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["toId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["stateHash", binary, State], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        521: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelForceProgressTx);
                serialize: ((value?: ChannelForceProgressTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["payload", binary, Transaction], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["update", binary, ContractBytearray], readonly ["stateHash", binary, State], readonly ["offChainTrees", stateTree], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        53: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelCloseMutualTx);
                serialize: ((value?: ChannelCloseMutualTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["initiatorAmountFinal", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["responderAmountFinal", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        54: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelCloseSoloTx);
                serialize: ((value?: ChannelCloseSoloTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["payload", binary, Transaction], readonly ["poi", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }) => TxUnpacked<Partial<Pick<{
                    version: undefined | 1;
                }, "version">> & Omit<{
                    version: undefined | 1;
                }, "version"> & Partial<Pick<{
                    tag: undefined | TreesPoi;
                }, "tag">> & Omit<{
                    tag: undefined | TreesPoi;
                }, "tag"> & Partial<Pick<{
                    accounts: MPTree<AccountAddress, Account>[];
                }, never>> & Omit<{
                    accounts: MPTree<AccountAddress, Account>[];
                }, never> & Partial<Pick<{
                    calls: MPTree<Bytearray, ContractCall>[];
                }, never>> & Omit<{
                    calls: MPTree<Bytearray, ContractCall>[];
                }, never> & Partial<Pick<{
                    channels: MPTree<Channel, Channel>[];
                }, never>> & Omit<{
                    channels: MPTree<Channel, Channel>[];
                }, never> & Partial<Pick<{
                    contracts: MPTree<ContractAddress, Contract>[];
                }, never>> & Omit<{
                    contracts: MPTree<ContractAddress, Contract>[];
                }, never> & Partial<Pick<{
                    ns: MPTree<Name, Name>[];
                }, never>> & Omit<{
                    ns: MPTree<Name, Name>[];
                }, never> & Partial<Pick<{
                    oracles: MPTree<OracleAddress, Oracle>[];
                }, never>> & Omit<{
                    oracles: MPTree<OracleAddress, Oracle>[];
                }, never>>);
                serialize: ((value: ({ tag: Tag.TreesPoi; version?: 1 | undefined; }) & Omit<Partial<Pick<{
                    version: undefined | 1;
                }, "version">> & Omit<{
                    version: undefined | 1;
                }, "version"> & Partial<Pick<{
                    tag: undefined | TreesPoi;
                }, "tag">> & Omit<{
                    tag: undefined | TreesPoi;
                }, "tag"> & Partial<Pick<{
                    accounts: MPTree<AccountAddress, Account>[];
                }, never>> & Omit<{
                    accounts: MPTree<AccountAddress, Account>[];
                }, never> & Partial<Pick<{
                    calls: MPTree<Bytearray, ContractCall>[];
                }, never>> & Omit<{
                    calls: MPTree<Bytearray, ContractCall>[];
                }, never> & Partial<Pick<{
                    channels: MPTree<Channel, Channel>[];
                }, never>> & Omit<{
                    channels: MPTree<Channel, Channel>[];
                }, never> & Partial<Pick<{
                    contracts: MPTree<ContractAddress, Contract>[];
                }, never>> & Omit<{
                    contracts: MPTree<ContractAddress, Contract>[];
                }, never> & Partial<Pick<{
                    ns: MPTree<Name, Name>[];
                }, never>> & Omit<{
                    ns: MPTree<Name, Name>[];
                }, never> & Partial<Pick<{
                    oracles: MPTree<OracleAddress, Oracle>[];
                }, never>> & Omit<{
                    oracles: MPTree<OracleAddress, Oracle>[];
                }, never>, "version" | "tag">, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        55: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelSlashTx);
                serialize: ((value?: ChannelSlashTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["payload", binary, Transaction], readonly ["poi", {
                deserialize: ((value: Buffer, options: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }) => TxUnpacked<Partial<Pick<{
                    version: undefined | 1;
                }, "version">> & Omit<{
                    version: undefined | 1;
                }, "version"> & Partial<Pick<{
                    tag: undefined | TreesPoi;
                }, "tag">> & Omit<{
                    tag: undefined | TreesPoi;
                }, "tag"> & Partial<Pick<{
                    accounts: MPTree<AccountAddress, Account>[];
                }, never>> & Omit<{
                    accounts: MPTree<AccountAddress, Account>[];
                }, never> & Partial<Pick<{
                    calls: MPTree<Bytearray, ContractCall>[];
                }, never>> & Omit<{
                    calls: MPTree<Bytearray, ContractCall>[];
                }, never> & Partial<Pick<{
                    channels: MPTree<Channel, Channel>[];
                }, never>> & Omit<{
                    channels: MPTree<Channel, Channel>[];
                }, never> & Partial<Pick<{
                    contracts: MPTree<ContractAddress, Contract>[];
                }, never>> & Omit<{
                    contracts: MPTree<ContractAddress, Contract>[];
                }, never> & Partial<Pick<{
                    ns: MPTree<Name, Name>[];
                }, never>> & Omit<{
                    ns: MPTree<Name, Name>[];
                }, never> & Partial<Pick<{
                    oracles: MPTree<OracleAddress, Oracle>[];
                }, never>> & Omit<{
                    oracles: MPTree<OracleAddress, Oracle>[];
                }, never>>);
                serialize: ((value: ({ tag: Tag.TreesPoi; version?: 1 | undefined; }) & Omit<Partial<Pick<{
                    version: undefined | 1;
                }, "version">> & Omit<{
                    version: undefined | 1;
                }, "version"> & Partial<Pick<{
                    tag: undefined | TreesPoi;
                }, "tag">> & Omit<{
                    tag: undefined | TreesPoi;
                }, "tag"> & Partial<Pick<{
                    accounts: MPTree<AccountAddress, Account>[];
                }, never>> & Omit<{
                    accounts: MPTree<AccountAddress, Account>[];
                }, never> & Partial<Pick<{
                    calls: MPTree<Bytearray, ContractCall>[];
                }, never>> & Omit<{
                    calls: MPTree<Bytearray, ContractCall>[];
                }, never> & Partial<Pick<{
                    channels: MPTree<Channel, Channel>[];
                }, never>> & Omit<{
                    channels: MPTree<Channel, Channel>[];
                }, never> & Partial<Pick<{
                    contracts: MPTree<ContractAddress, Contract>[];
                }, never>> & Omit<{
                    contracts: MPTree<ContractAddress, Contract>[];
                }, never> & Partial<Pick<{
                    ns: MPTree<Name, Name>[];
                }, never>> & Omit<{
                    ns: MPTree<Name, Name>[];
                }, never> & Partial<Pick<{
                    oracles: MPTree<OracleAddress, Oracle>[];
                }, never>> & Omit<{
                    oracles: MPTree<OracleAddress, Oracle>[];
                }, never>, "version" | "tag">, options: {
                    buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                        gasMax?: number;
                    } : {}), options?: {
                        denomination?: AE_AMOUNT_FORMATS;
                        prefix?: E;
                    }) => Generic<E>);
                }) => Buffer);
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        56: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelSettleTx);
                serialize: ((value?: ChannelSettleTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["initiatorAmountFinal", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["responderAmountFinal", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        57: {
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainTx);
                serialize: ((value?: ChannelOffChainTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["stateHash", binary, State]];
        };
        570: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
                serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["from", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["to", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }]];
        };
        571: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
                serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["from", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }]];
        };
        572: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
                serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["from", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }]];
        };
        573: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
                serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["owner", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["deposit", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["callData", binary, ContractBytearray]];
        };
        574: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
                serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["caller", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["contract", {
                deserialize: ((value: Buffer) => `ct_${string}`);
                serialize: ((value: `ct_${string}`) => Buffer);
            }], readonly ["abiVersion", {
                deserialize: ((value: Buffer) => ABI_VERSIONS);
                serialize: ((value: ABI_VERSIONS) => Buffer);
            }], readonly ["amount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["callData", binary, ContractBytearray], readonly ["callStack", callStack], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): Buffer;
            }]];
        };
        575: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelClientReconnectTx);
                serialize: ((value?: ChannelClientReconnectTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["role", string], readonly ["pubkey", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }]];
        };
        58: {
            3: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Channel);
                serialize: ((value?: Channel) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 3);
                serialize: ((value?: 3) => Buffer);
            }], readonly ["initiator", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["responder", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["channelAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["initiatorAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["responderAmount", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["channelReserve", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["initiatorDelegateIds", {
                deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
            }], readonly ["responderDelegateIds", {
                deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
            }], readonly ["stateHash", hex], readonly ["round", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["soloRound", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["lockPeriod", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["lockedUntil", {
                deserialize(value: Buffer): string;
                serialize(value: Int): Buffer;
            }], readonly ["initiatorAuth", binary, ContractBytearray], readonly ["responderAuth", binary, ContractBytearray]];
        };
        59: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
                serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channelId", {
                deserialize: ((value: Buffer) => `ch_${string}`);
                serialize: ((value: `ch_${string}`) => Buffer);
            }], readonly ["fromId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["payload", binary, Transaction], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }]];
        };
        60: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => TreesPoi);
                serialize: ((value?: TreesPoi) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accounts", {
                deserialize: ((value: MPTreeBinary[], o: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }) => MPTree<AccountAddress, Account>[]);
                serialize: ((value: MPTree<AccountAddress, Account>[]) => MPTreeBinary[]);
            }], readonly ["calls", {
                deserialize: ((value: MPTreeBinary[], o: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }) => MPTree<Bytearray, ContractCall>[]);
                serialize: ((value: MPTree<Bytearray, ContractCall>[]) => MPTreeBinary[]);
            }], readonly ["channels", {
                deserialize: ((value: MPTreeBinary[], o: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }) => MPTree<Channel, Channel>[]);
                serialize: ((value: MPTree<Channel, Channel>[]) => MPTreeBinary[]);
            }], readonly ["contracts", {
                deserialize: ((value: MPTreeBinary[], o: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }) => MPTree<ContractAddress, Contract>[]);
                serialize: ((value: MPTree<ContractAddress, Contract>[]) => MPTreeBinary[]);
            }], readonly ["ns", {
                deserialize: ((value: MPTreeBinary[], o: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }) => MPTree<Name, Name>[]);
                serialize: ((value: MPTree<Name, Name>[]) => MPTreeBinary[]);
            }], readonly ["oracles", {
                deserialize: ((value: MPTreeBinary[], o: {
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }) => MPTree<OracleAddress, Oracle>[]);
                serialize: ((value: MPTree<OracleAddress, Oracle>[]) => MPTreeBinary[]);
            }]];
        };
        62: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => StateTrees);
                serialize: ((value?: StateTrees) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["contracts", rlpBinary], readonly ["calls", rlpBinary], readonly ["channels", rlpBinary], readonly ["ns", rlpBinary], readonly ["oracles", rlpBinary], readonly ["accounts", rlpBinary]];
        };
        621: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ContractsMtree);
                serialize: ((value?: ContractsMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["contracts", rlpBinary]];
        };
        622: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => CallsMtree);
                serialize: ((value?: CallsMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["calls", rlpBinary]];
        };
        623: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => ChannelsMtree);
                serialize: ((value?: ChannelsMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["channels", rlpBinary]];
        };
        624: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => NameserviceMtree);
                serialize: ((value?: NameserviceMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["mtree", rlpBinary]];
        };
        625: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => OraclesMtree);
                serialize: ((value?: OraclesMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["otree", rlpBinary]];
        };
        626: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => AccountsMtree);
                serialize: ((value?: AccountsMtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["accounts", rlpBinary]];
        };
        63: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => Mtree);
                serialize: ((value?: Mtree) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["values", rlpBinaries]];
        };
        64: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => MtreeValue);
                serialize: ((value?: MtreeValue) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["key", hex], readonly ["value", rawBinary]];
        };
        70: {
            3: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => CompilerSophia);
                serialize: ((value?: CompilerSophia) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 3);
                serialize: ((value?: 3) => Buffer);
            }], readonly ["sourceCodeHash", rawBinary], readonly ["typeInfo", sophiaCodeTypeInfo], readonly ["byteCode", rawBinary], readonly ["compilerVersion", string], readonly ["payable", bool]];
        };
        80: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => GaAttachTx);
                serialize: ((value?: GaAttachTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["ownerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["code", binary, ContractBytearray], readonly ["authFun", rawBinary], readonly ["ctVersion", ctVersion], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["ttl", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): Buffer;
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["callData", binary, ContractBytearray]];
        };
        81: {
            2: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => GaMetaTx);
                serialize: ((value?: GaMetaTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 2);
                serialize: ((value?: 2) => Buffer);
            }], readonly ["gaId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["authData", binary, ContractBytearray], readonly ["abiVersion", {
                deserialize: ((value: Buffer) => ABI_VERSIONS);
                serialize: ((value: ABI_VERSIONS) => Buffer);
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["gasLimit", {
                deserialize(value: Buffer): number;
                serialize(_value: undefined | number, __namedParameters: {
                    _computingGasLimit?: number;
                    gasMax: number;
                    rebuildTx: ((params: any) => any);
                    tag: Tag;
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): Buffer;
            }], readonly ["gasPrice", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(value?: undefined | string): string;
            }], readonly ["tx", rlpBinary]];
        };
        82: {
            1: readonly [readonly ["tag", {
                deserialize: ((value: Buffer) => PayingForTx);
                serialize: ((value?: PayingForTx) => Buffer);
            }], readonly ["version", {
                deserialize: ((value: Buffer) => 1);
                serialize: ((value?: 1) => Buffer);
            }], readonly ["payerId", {
                deserialize: ((value: Buffer) => `ak_${string}`);
                serialize: ((value: `ak_${string}`) => Buffer);
            }], readonly ["nonce", {
                deserialize(value: Buffer): number;
                serialize(value: number): Buffer;
            }], readonly ["fee", {
                deserialize(value: Buffer): string;
                serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                serializeAettos(_value: undefined | string, __namedParameters: {
                    _computingMinFee?: BigNumber;
                    _pickBiggerFee?: boolean;
                    rebuildTx: ((params: any) => `tx_${string}`);
                    unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                }): string;
            }], readonly ["tx", rlpBinary]];
        };
    }[TxType]>, number>;
} & Omit<TxTypeSchemaBy<TxType, Extract<KeysOfUnion<{
    10: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Account);
            serialize: ((value?: Account) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["balance", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }]];
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Account);
            serialize: ((value?: Account) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["flags", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["balance", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["gaContract", {
            deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
            serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["gaAuthFun", binary, ContractBytearray]];
    };
    11: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => SignedTx);
            serialize: ((value?: SignedTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["signatures", signatures], readonly ["encodedTx", rlpBinary]];
    };
    12: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => SpendTx);
            serialize: ((value?: SpendTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["senderId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["recipientId", {
            deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
            serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["payload", payload]];
    };
    20: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Oracle);
            serialize: ((value?: Oracle) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["oracleTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["abiVersion", {
            deserialize: ((value: Buffer) => ABI_VERSIONS);
            serialize: ((value: ABI_VERSIONS) => Buffer);
        }]];
    };
    22: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OracleRegisterTx);
            serialize: ((value?: OracleRegisterTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["oracleTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["oracleTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["abiVersion", {
            deserialize: ((value: Buffer) => ABI_VERSIONS);
            serialize: ((value: ABI_VERSIONS) => Buffer);
        }]];
    };
    23: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OracleQueryTx);
            serialize: ((value?: OracleQueryTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["senderId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["oracleId", {
            deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
            serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["query", string], readonly ["queryFee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["queryTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["queryTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["responseTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["responseTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    24: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OracleResponseTx);
            serialize: ((value?: OracleResponseTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["oracleId", {
            deserialize: ((value: Buffer) => `ok_${string}`);
            serialize: ((value: `ok_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["queryId", binary, OracleQueryId], readonly ["response", string], readonly ["responseTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["responseTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    25: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OracleExtendTx);
            serialize: ((value?: OracleExtendTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["oracleId", {
            deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
            serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["oracleTtlType", {
            deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
            serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
        }], readonly ["oracleTtlValue", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    30: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Name);
            serialize: ((value?: Name) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nameTtl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["status", binary], readonly ["clientTtl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["pointers", {
            deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
            serialize(pointers: NamePointer[]): Buffer[][];
        }]];
    };
    32: {
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameClaimTx);
            serialize: ((value?: NameClaimTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["name", {
            deserialize(value: Buffer): `${string}.chain`;
            serialize(value: `${string}.chain`): Buffer;
        }], readonly ["nameSalt", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["nameFee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, txFields: {
                name: `${string}.chain`;
            } & Options): Buffer;
            serializeAettos(_value: undefined | string, txFields: {
                name: `${string}.chain`;
            }): string;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    33: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NamePreclaimTx);
            serialize: ((value?: NamePreclaimTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["commitmentId", {
            deserialize: ((value: Buffer) => `cm_${string}`);
            serialize: ((value: `cm_${string}`) => Buffer);
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    34: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameUpdateTx);
            serialize: ((value?: NameUpdateTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nameId", {
            deserialize: ((value: Buffer) => `nm_${string}`);
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        }], readonly ["nameTtl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["pointers", {
            deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
            serialize(pointers: NamePointer[]): Buffer[][];
        }], readonly ["clientTtl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    35: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameRevokeTx);
            serialize: ((value?: NameRevokeTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nameId", {
            deserialize: ((value: Buffer) => `nm_${string}`);
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    36: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameTransferTx);
            serialize: ((value?: NameTransferTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accountId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nameId", {
            deserialize: ((value: Buffer) => `nm_${string}`);
            serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
        }], readonly ["recipientId", {
            deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
            serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    40: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Contract);
            serialize: ((value?: Contract) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["owner", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["log", binary, ContractBytearray], readonly ["active", bool], readonly ["referers", {
            deserialize: ((value: Buffer[]) => `ak_${string}`[]);
            serialize: ((value: `ak_${string}`[]) => Buffer[]);
        }], readonly ["deposit", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, options: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }]];
    };
    41: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ContractCall);
            serialize: ((value?: ContractCall) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["callerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["callerNonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["height", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["contractId", {
            deserialize: ((value: Buffer) => `ct_${string}`);
            serialize: ((value: `ct_${string}`) => Buffer);
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["gasUsed", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["returnValue", binary, ContractBytearray], readonly ["returnType", {
            deserialize: ((value: Buffer) => CallReturnType);
            serialize: ((value: CallReturnType) => Buffer);
        }], readonly ["log", rawBinary]];
    };
    42: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ContractCreateTx);
            serialize: ((value?: ContractCreateTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["ownerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["code", binary, ContractBytearray], readonly ["ctVersion", ctVersion], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["deposit", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, options: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): Buffer;
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["callData", binary, ContractBytearray]];
    };
    43: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ContractCallTx);
            serialize: ((value?: ContractCallTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["callerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["contractId", {
            deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
            serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
        }], readonly ["abiVersion", {
            deserialize: ((value: Buffer) => ABI_VERSIONS);
            serialize: ((value: ABI_VERSIONS) => Buffer);
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value: undefined | string): string;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): Buffer;
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["callData", binary, ContractBytearray]];
    };
    50: {
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelCreateTx);
            serialize: ((value?: ChannelCreateTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["initiator", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["initiatorAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["responder", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["responderAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["channelReserve", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["lockPeriod", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["initiatorDelegateIds", string], readonly ["responderDelegateIds", string], readonly ["stateHash", binary, State], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    51: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelDepositTx);
            serialize: ((value?: ChannelDepositTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["stateHash", binary, State], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    52: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelWithdrawTx);
            serialize: ((value?: ChannelWithdrawTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["toId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["stateHash", binary, State], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    521: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelForceProgressTx);
            serialize: ((value?: ChannelForceProgressTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["payload", binary, Transaction], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["update", binary, ContractBytearray], readonly ["stateHash", binary, State], readonly ["offChainTrees", stateTree], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    53: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelCloseMutualTx);
            serialize: ((value?: ChannelCloseMutualTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["initiatorAmountFinal", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["responderAmountFinal", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    54: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelCloseSoloTx);
            serialize: ((value?: ChannelCloseSoloTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["payload", binary, Transaction], readonly ["poi", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }) => TxUnpacked<Partial<Pick<{
                version: undefined | 1;
            }, "version">> & Omit<{
                version: undefined | 1;
            }, "version"> & Partial<Pick<{
                tag: undefined | TreesPoi;
            }, "tag">> & Omit<{
                tag: undefined | TreesPoi;
            }, "tag"> & Partial<Pick<{
                accounts: MPTree<AccountAddress, Account>[];
            }, never>> & Omit<{
                accounts: MPTree<AccountAddress, Account>[];
            }, never> & Partial<Pick<{
                calls: MPTree<Bytearray, ContractCall>[];
            }, never>> & Omit<{
                calls: MPTree<Bytearray, ContractCall>[];
            }, never> & Partial<Pick<{
                channels: MPTree<Channel, Channel>[];
            }, never>> & Omit<{
                channels: MPTree<Channel, Channel>[];
            }, never> & Partial<Pick<{
                contracts: MPTree<ContractAddress, Contract>[];
            }, never>> & Omit<{
                contracts: MPTree<ContractAddress, Contract>[];
            }, never> & Partial<Pick<{
                ns: MPTree<Name, Name>[];
            }, never>> & Omit<{
                ns: MPTree<Name, Name>[];
            }, never> & Partial<Pick<{
                oracles: MPTree<OracleAddress, Oracle>[];
            }, never>> & Omit<{
                oracles: MPTree<OracleAddress, Oracle>[];
            }, never>>);
            serialize: ((value: {
                tag: TreesPoi;
                version?: 1;
            } & Omit<Partial<Pick<{
                version: undefined | 1;
            }, "version">> & Omit<{
                version: undefined | 1;
            }, "version"> & Partial<Pick<{
                tag: undefined | TreesPoi;
            }, "tag">> & Omit<{
                tag: undefined | TreesPoi;
            }, "tag"> & Partial<Pick<{
                accounts: MPTree<AccountAddress, Account>[];
            }, never>> & Omit<{
                accounts: MPTree<AccountAddress, Account>[];
            }, never> & Partial<Pick<{
                calls: MPTree<Bytearray, ContractCall>[];
            }, never>> & Omit<{
                calls: MPTree<Bytearray, ContractCall>[];
            }, never> & Partial<Pick<{
                channels: MPTree<Channel, Channel>[];
            }, never>> & Omit<{
                channels: MPTree<Channel, Channel>[];
            }, never> & Partial<Pick<{
                contracts: MPTree<ContractAddress, Contract>[];
            }, never>> & Omit<{
                contracts: MPTree<ContractAddress, Contract>[];
            }, never> & Partial<Pick<{
                ns: MPTree<Name, Name>[];
            }, never>> & Omit<{
                ns: MPTree<Name, Name>[];
            }, never> & Partial<Pick<{
                oracles: MPTree<OracleAddress, Oracle>[];
            }, never>> & Omit<{
                oracles: MPTree<OracleAddress, Oracle>[];
            }, never>, "version" | "tag">, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    55: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelSlashTx);
            serialize: ((value?: ChannelSlashTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["payload", binary, Transaction], readonly ["poi", {
            deserialize: ((value: Buffer, options: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }) => TxUnpacked<Partial<Pick<{
                version: undefined | 1;
            }, "version">> & Omit<{
                version: undefined | 1;
            }, "version"> & Partial<Pick<{
                tag: undefined | TreesPoi;
            }, "tag">> & Omit<{
                tag: undefined | TreesPoi;
            }, "tag"> & Partial<Pick<{
                accounts: MPTree<AccountAddress, Account>[];
            }, never>> & Omit<{
                accounts: MPTree<AccountAddress, Account>[];
            }, never> & Partial<Pick<{
                calls: MPTree<Bytearray, ContractCall>[];
            }, never>> & Omit<{
                calls: MPTree<Bytearray, ContractCall>[];
            }, never> & Partial<Pick<{
                channels: MPTree<Channel, Channel>[];
            }, never>> & Omit<{
                channels: MPTree<Channel, Channel>[];
            }, never> & Partial<Pick<{
                contracts: MPTree<ContractAddress, Contract>[];
            }, never>> & Omit<{
                contracts: MPTree<ContractAddress, Contract>[];
            }, never> & Partial<Pick<{
                ns: MPTree<Name, Name>[];
            }, never>> & Omit<{
                ns: MPTree<Name, Name>[];
            }, never> & Partial<Pick<{
                oracles: MPTree<OracleAddress, Oracle>[];
            }, never>> & Omit<{
                oracles: MPTree<OracleAddress, Oracle>[];
            }, never>>);
            serialize: ((value: {
                tag: TreesPoi;
                version?: 1;
            } & Omit<Partial<Pick<{
                version: undefined | 1;
            }, "version">> & Omit<{
                version: undefined | 1;
            }, "version"> & Partial<Pick<{
                tag: undefined | TreesPoi;
            }, "tag">> & Omit<{
                tag: undefined | TreesPoi;
            }, "tag"> & Partial<Pick<{
                accounts: MPTree<AccountAddress, Account>[];
            }, never>> & Omit<{
                accounts: MPTree<AccountAddress, Account>[];
            }, never> & Partial<Pick<{
                calls: MPTree<Bytearray, ContractCall>[];
            }, never>> & Omit<{
                calls: MPTree<Bytearray, ContractCall>[];
            }, never> & Partial<Pick<{
                channels: MPTree<Channel, Channel>[];
            }, never>> & Omit<{
                channels: MPTree<Channel, Channel>[];
            }, never> & Partial<Pick<{
                contracts: MPTree<ContractAddress, Contract>[];
            }, never>> & Omit<{
                contracts: MPTree<ContractAddress, Contract>[];
            }, never> & Partial<Pick<{
                ns: MPTree<Name, Name>[];
            }, never>> & Omit<{
                ns: MPTree<Name, Name>[];
            }, never> & Partial<Pick<{
                oracles: MPTree<OracleAddress, Oracle>[];
            }, never>> & Omit<{
                oracles: MPTree<OracleAddress, Oracle>[];
            }, never>, "version" | "tag">, options: {
                buildTx: (<TxType, E, Version>(params: {
                    tag: TxType;
                    version?: Version;
                } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                    gasMax?: number;
                } : {}), options?: {
                    denomination?: AE_AMOUNT_FORMATS;
                    prefix?: E;
                }) => Generic<E>);
            }) => Buffer);
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    56: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelSettleTx);
            serialize: ((value?: ChannelSettleTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["initiatorAmountFinal", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["responderAmountFinal", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    57: {
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainTx);
            serialize: ((value?: ChannelOffChainTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["stateHash", binary, State]];
    };
    570: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
            serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["from", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["to", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }]];
    };
    571: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
            serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["from", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }]];
    };
    572: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
            serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["from", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }]];
    };
    573: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
            serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["owner", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["deposit", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["callData", binary, ContractBytearray]];
    };
    574: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
            serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["caller", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["contract", {
            deserialize: ((value: Buffer) => `ct_${string}`);
            serialize: ((value: `ct_${string}`) => Buffer);
        }], readonly ["abiVersion", {
            deserialize: ((value: Buffer) => ABI_VERSIONS);
            serialize: ((value: ABI_VERSIONS) => Buffer);
        }], readonly ["amount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["callData", binary, ContractBytearray], readonly ["callStack", callStack], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): Buffer;
        }]];
    };
    575: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelClientReconnectTx);
            serialize: ((value?: ChannelClientReconnectTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["role", string], readonly ["pubkey", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }]];
    };
    58: {
        3: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Channel);
            serialize: ((value?: Channel) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 3);
            serialize: ((value?: 3) => Buffer);
        }], readonly ["initiator", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["responder", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["channelAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["initiatorAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["responderAmount", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["channelReserve", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["initiatorDelegateIds", {
            deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
        }], readonly ["responderDelegateIds", {
            deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
            serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
        }], readonly ["stateHash", hex], readonly ["round", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["soloRound", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["lockPeriod", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["lockedUntil", {
            deserialize(value: Buffer): string;
            serialize(value: Int): Buffer;
        }], readonly ["initiatorAuth", binary, ContractBytearray], readonly ["responderAuth", binary, ContractBytearray]];
    };
    59: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
            serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channelId", {
            deserialize: ((value: Buffer) => `ch_${string}`);
            serialize: ((value: `ch_${string}`) => Buffer);
        }], readonly ["fromId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["payload", binary, Transaction], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }]];
    };
    60: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => TreesPoi);
            serialize: ((value?: TreesPoi) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accounts", {
            deserialize: ((value: MPTreeBinary[], o: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }) => MPTree<AccountAddress, Account>[]);
            serialize: ((value: MPTree<AccountAddress, Account>[]) => MPTreeBinary[]);
        }], readonly ["calls", {
            deserialize: ((value: MPTreeBinary[], o: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }) => MPTree<Bytearray, ContractCall>[]);
            serialize: ((value: MPTree<Bytearray, ContractCall>[]) => MPTreeBinary[]);
        }], readonly ["channels", {
            deserialize: ((value: MPTreeBinary[], o: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }) => MPTree<Channel, Channel>[]);
            serialize: ((value: MPTree<Channel, Channel>[]) => MPTreeBinary[]);
        }], readonly ["contracts", {
            deserialize: ((value: MPTreeBinary[], o: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }) => MPTree<ContractAddress, Contract>[]);
            serialize: ((value: MPTree<ContractAddress, Contract>[]) => MPTreeBinary[]);
        }], readonly ["ns", {
            deserialize: ((value: MPTreeBinary[], o: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }) => MPTree<Name, Name>[]);
            serialize: ((value: MPTree<Name, Name>[]) => MPTreeBinary[]);
        }], readonly ["oracles", {
            deserialize: ((value: MPTreeBinary[], o: {
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }) => MPTree<OracleAddress, Oracle>[]);
            serialize: ((value: MPTree<OracleAddress, Oracle>[]) => MPTreeBinary[]);
        }]];
    };
    62: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => StateTrees);
            serialize: ((value?: StateTrees) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["contracts", rlpBinary], readonly ["calls", rlpBinary], readonly ["channels", rlpBinary], readonly ["ns", rlpBinary], readonly ["oracles", rlpBinary], readonly ["accounts", rlpBinary]];
    };
    621: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ContractsMtree);
            serialize: ((value?: ContractsMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["contracts", rlpBinary]];
    };
    622: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => CallsMtree);
            serialize: ((value?: CallsMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["calls", rlpBinary]];
    };
    623: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => ChannelsMtree);
            serialize: ((value?: ChannelsMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["channels", rlpBinary]];
    };
    624: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => NameserviceMtree);
            serialize: ((value?: NameserviceMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["mtree", rlpBinary]];
    };
    625: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => OraclesMtree);
            serialize: ((value?: OraclesMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["otree", rlpBinary]];
    };
    626: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => AccountsMtree);
            serialize: ((value?: AccountsMtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["accounts", rlpBinary]];
    };
    63: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => Mtree);
            serialize: ((value?: Mtree) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["values", rlpBinaries]];
    };
    64: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => MtreeValue);
            serialize: ((value?: MtreeValue) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["key", hex], readonly ["value", rawBinary]];
    };
    70: {
        3: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => CompilerSophia);
            serialize: ((value?: CompilerSophia) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 3);
            serialize: ((value?: 3) => Buffer);
        }], readonly ["sourceCodeHash", rawBinary], readonly ["typeInfo", sophiaCodeTypeInfo], readonly ["byteCode", rawBinary], readonly ["compilerVersion", string], readonly ["payable", bool]];
    };
    80: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => GaAttachTx);
            serialize: ((value?: GaAttachTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["ownerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["code", binary, ContractBytearray], readonly ["authFun", rawBinary], readonly ["ctVersion", ctVersion], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["ttl", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): Buffer;
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["callData", binary, ContractBytearray]];
    };
    81: {
        2: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => GaMetaTx);
            serialize: ((value?: GaMetaTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 2);
            serialize: ((value?: 2) => Buffer);
        }], readonly ["gaId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["authData", binary, ContractBytearray], readonly ["abiVersion", {
            deserialize: ((value: Buffer) => ABI_VERSIONS);
            serialize: ((value: ABI_VERSIONS) => Buffer);
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["gasLimit", {
            deserialize(value: Buffer): number;
            serialize(_value: undefined | number, __namedParameters: {
                _computingGasLimit?: number;
                gasMax: number;
                rebuildTx: ((params: any) => any);
                tag: Tag;
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): Buffer;
        }], readonly ["gasPrice", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(value?: undefined | string): string;
        }], readonly ["tx", rlpBinary]];
    };
    82: {
        1: readonly [readonly ["tag", {
            deserialize: ((value: Buffer) => PayingForTx);
            serialize: ((value?: PayingForTx) => Buffer);
        }], readonly ["version", {
            deserialize: ((value: Buffer) => 1);
            serialize: ((value?: 1) => Buffer);
        }], readonly ["payerId", {
            deserialize: ((value: Buffer) => `ak_${string}`);
            serialize: ((value: `ak_${string}`) => Buffer);
        }], readonly ["nonce", {
            deserialize(value: Buffer): number;
            serialize(value: number): Buffer;
        }], readonly ["fee", {
            deserialize(value: Buffer): string;
            serialize(value: undefined | Int, __namedParameters: Options): Buffer;
            serializeAettos(_value: undefined | string, __namedParameters: {
                _computingMinFee?: BigNumber;
                _pickBiggerFee?: boolean;
                rebuildTx: ((params: any) => `tx_${string}`);
                unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
            }): string;
        }], readonly ["tx", rlpBinary]];
    };
}[TxType]>, number>>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
    gasMax?: number;
} : {}), "nonce" | "ttl" | "abiVersion" | "tag" | "ctVersion"> & {
    denomination?: AE_AMOUNT_FORMATS;
} & Omit<{
    absoluteTtl?: boolean;
    onNode: Node;
    senderId: `ak_${string}`;
    strategy?: "max" | "continuity";
} & Pick<Partial<Partial<Pick<{
    tag: undefined | Account;
}, "tag">> & Omit<{
    tag: undefined | Account;
}, "tag"> & Partial<Pick<{
    nonce: number;
}, never>> & Omit<{
    nonce: number;
}, never> & Partial<Pick<{
    balance: Int;
}, never>> & Omit<{
    balance: Int;
}, never> & Partial<Pick<{
    version: undefined | 2;
}, "version">> & Omit<{
    version: undefined | 2;
}, "version"> & Partial<Pick<{
    flags: Int;
}, never>> & Omit<{
    flags: Int;
}, never> & Partial<Pick<{
    gaContract: `ct_${string}` | `nm_${string}`;
}, never>> & Omit<{
    gaContract: `ct_${string}` | `nm_${string}`;
}, never> & Partial<Pick<{
    gaAuthFun: `cb_${string}`;
}, never>> & Omit<{
    gaAuthFun: `cb_${string}`;
}, never> & Partial<Pick<{
    version: undefined | 1;
}, "version">> & Omit<{
    version: undefined | 1;
}, "version"> & Partial<Pick<{
    tag: undefined | SignedTx;
}, "tag">> & Omit<{
    tag: undefined | SignedTx;
}, "tag"> & Partial<Pick<{
    signatures: Uint8Array[];
}, never>> & Omit<{
    signatures: Uint8Array[];
}, never> & Partial<Pick<{
    encodedTx: any;
}, "encodedTx">> & Omit<{
    encodedTx: any;
}, "encodedTx"> & Partial<Pick<{
    tag: undefined | SpendTx;
}, "tag">> & Omit<{
    tag: undefined | SpendTx;
}, "tag"> & Partial<Pick<{
    senderId: `ak_${string}`;
}, never>> & Omit<{
    senderId: `ak_${string}`;
}, never> & Partial<Pick<{
    recipientId: `ak_${string}` | `nm_${string}`;
}, never>> & Omit<{
    recipientId: `ak_${string}` | `nm_${string}`;
}, never> & Partial<Pick<{
    amount: undefined | Int;
}, "amount">> & Omit<{
    amount: undefined | Int;
}, "amount"> & Partial<Pick<{
    fee: undefined | Int;
}, "fee">> & Omit<{
    fee: undefined | Int;
}, "fee"> & Partial<Pick<{
    ttl: number;
}, never>> & Omit<{
    ttl: number;
}, never> & Partial<Pick<{
    payload: undefined | string;
}, "payload">> & Omit<{
    payload: undefined | string;
}, "payload"> & Partial<Pick<{
    accountId: `ak_${string}`;
}, never>> & Omit<{
    accountId: `ak_${string}`;
}, never> & Partial<Pick<{
    abiVersion: ABI_VERSIONS;
}, never>> & Omit<{
    abiVersion: ABI_VERSIONS;
}, never> & Partial<Pick<{
    tag: undefined | Oracle;
}, "tag">> & Omit<{
    tag: undefined | Oracle;
}, "tag"> & Partial<Pick<{
    queryFormat: string;
}, never>> & Omit<{
    queryFormat: string;
}, never> & Partial<Pick<{
    responseFormat: string;
}, never>> & Omit<{
    responseFormat: string;
}, never> & Partial<Pick<{
    queryFee: undefined | Int;
}, "queryFee">> & Omit<{
    queryFee: undefined | Int;
}, "queryFee"> & Partial<Pick<{
    oracleTtlValue: number;
}, never>> & Omit<{
    oracleTtlValue: number;
}, never> & Partial<Pick<{
    tag: undefined | OracleRegisterTx;
}, "tag">> & Omit<{
    tag: undefined | OracleRegisterTx;
}, "tag"> & Partial<Pick<{
    oracleTtlType: ORACLE_TTL_TYPES;
}, never>> & Omit<{
    oracleTtlType: ORACLE_TTL_TYPES;
}, never> & Partial<Pick<{
    oracleId: `ok_${string}` | `nm_${string}`;
}, never>> & Omit<{
    oracleId: `ok_${string}` | `nm_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | OracleQueryTx;
}, "tag">> & Omit<{
    tag: undefined | OracleQueryTx;
}, "tag"> & Partial<Pick<{
    query: string;
}, never>> & Omit<{
    query: string;
}, never> & Partial<Pick<{
    queryTtlType: ORACLE_TTL_TYPES;
}, never>> & Omit<{
    queryTtlType: ORACLE_TTL_TYPES;
}, never> & Partial<Pick<{
    queryTtlValue: number;
}, never>> & Omit<{
    queryTtlValue: number;
}, never> & Partial<Pick<{
    responseTtlType: ORACLE_TTL_TYPES;
}, never>> & Omit<{
    responseTtlType: ORACLE_TTL_TYPES;
}, never> & Partial<Pick<{
    responseTtlValue: number;
}, never>> & Omit<{
    responseTtlValue: number;
}, never> & Partial<Pick<{
    tag: undefined | OracleResponseTx;
}, "tag">> & Omit<{
    tag: undefined | OracleResponseTx;
}, "tag"> & Partial<Pick<{
    oracleId: `ok_${string}`;
}, never>> & Omit<{
    oracleId: `ok_${string}`;
}, never> & Partial<Pick<{
    queryId: `oq_${string}`;
}, never>> & Omit<{
    queryId: `oq_${string}`;
}, never> & Partial<Pick<{
    response: string;
}, never>> & Omit<{
    response: string;
}, never> & Partial<Pick<{
    tag: undefined | OracleExtendTx;
}, "tag">> & Omit<{
    tag: undefined | OracleExtendTx;
}, "tag"> & Partial<Pick<{
    tag: undefined | Name;
}, "tag">> & Omit<{
    tag: undefined | Name;
}, "tag"> & Partial<Pick<{
    nameTtl: number;
}, never>> & Omit<{
    nameTtl: number;
}, never> & Partial<Pick<{
    status: `${any}_${string}`;
}, never>> & Omit<{
    status: `${any}_${string}`;
}, never> & Partial<Pick<{
    clientTtl: number;
}, never>> & Omit<{
    clientTtl: number;
}, never> & Partial<Pick<{
    pointers: NamePointer[];
}, never>> & Omit<{
    pointers: NamePointer[];
}, never> & Partial<Pick<{
    tag: undefined | NameClaimTx;
}, "tag">> & Omit<{
    tag: undefined | NameClaimTx;
}, "tag"> & Partial<Pick<{
    name: `${string}.chain`;
}, never>> & Omit<{
    name: `${string}.chain`;
}, never> & Partial<Pick<{
    nameSalt: Int;
}, never>> & Omit<{
    nameSalt: Int;
}, never> & Partial<Pick<{
    nameFee: undefined | Int;
}, "nameFee">> & Omit<{
    nameFee: undefined | Int;
}, "nameFee"> & Partial<Pick<{
    tag: undefined | NamePreclaimTx;
}, "tag">> & Omit<{
    tag: undefined | NamePreclaimTx;
}, "tag"> & Partial<Pick<{
    commitmentId: `cm_${string}`;
}, never>> & Omit<{
    commitmentId: `cm_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | NameUpdateTx;
}, "tag">> & Omit<{
    tag: undefined | NameUpdateTx;
}, "tag"> & Partial<Pick<{
    nameId: `${string}.chain` | `nm_${string}`;
}, never>> & Omit<{
    nameId: `${string}.chain` | `nm_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | NameRevokeTx;
}, "tag">> & Omit<{
    tag: undefined | NameRevokeTx;
}, "tag"> & Partial<Pick<{
    tag: undefined | NameTransferTx;
}, "tag">> & Omit<{
    tag: undefined | NameTransferTx;
}, "tag"> & Partial<Pick<{
    tag: undefined | Contract;
}, "tag">> & Omit<{
    tag: undefined | Contract;
}, "tag"> & Partial<Pick<{
    owner: `ak_${string}`;
}, never>> & Omit<{
    owner: `ak_${string}`;
}, never> & Partial<Pick<{
    ctVersion: CtVersion;
}, never>> & Omit<{
    ctVersion: CtVersion;
}, never> & Partial<Pick<{
    code: `cb_${string}`;
}, never>> & Omit<{
    code: `cb_${string}`;
}, never> & Partial<Pick<{
    log: `cb_${string}`;
}, never>> & Omit<{
    log: `cb_${string}`;
}, never> & Partial<Pick<{
    active: Boolean;
}, never>> & Omit<{
    active: Boolean;
}, never> & Partial<Pick<{
    referers: `ak_${string}`[];
}, never>> & Omit<{
    referers: `ak_${string}`[];
}, never> & Partial<Pick<{
    deposit: undefined | Int;
}, "deposit">> & Omit<{
    deposit: undefined | Int;
}, "deposit"> & Partial<Pick<{
    gasPrice: undefined | Int;
}, "gasPrice">> & Omit<{
    gasPrice: undefined | Int;
}, "gasPrice"> & Partial<Pick<{
    callerId: `ak_${string}`;
}, never>> & Omit<{
    callerId: `ak_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | ContractCall;
}, "tag">> & Omit<{
    tag: undefined | ContractCall;
}, "tag"> & Partial<Pick<{
    callerNonce: number;
}, never>> & Omit<{
    callerNonce: number;
}, never> & Partial<Pick<{
    height: number;
}, never>> & Omit<{
    height: number;
}, never> & Partial<Pick<{
    contractId: `ct_${string}`;
}, never>> & Omit<{
    contractId: `ct_${string}`;
}, never> & Partial<Pick<{
    gasUsed: number;
}, never>> & Omit<{
    gasUsed: number;
}, never> & Partial<Pick<{
    returnValue: `cb_${string}`;
}, never>> & Omit<{
    returnValue: `cb_${string}`;
}, never> & Partial<Pick<{
    returnType: CallReturnType;
}, never>> & Omit<{
    returnType: CallReturnType;
}, never> & Partial<Pick<{
    log: Uint8Array;
}, never>> & Omit<{
    log: Uint8Array;
}, never> & Partial<Pick<{
    tag: undefined | ContractCreateTx;
}, "tag">> & Omit<{
    tag: undefined | ContractCreateTx;
}, "tag"> & Partial<Pick<{
    ownerId: `ak_${string}`;
}, never>> & Omit<{
    ownerId: `ak_${string}`;
}, never> & Partial<Pick<{
    gasLimit: undefined | number;
}, "gasLimit">> & Omit<{
    gasLimit: undefined | number;
}, "gasLimit"> & Partial<Pick<{
    callData: `cb_${string}`;
}, never>> & Omit<{
    callData: `cb_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | ContractCallTx;
}, "tag">> & Omit<{
    tag: undefined | ContractCallTx;
}, "tag"> & Partial<Pick<{
    contractId: `ct_${string}` | `nm_${string}`;
}, never>> & Omit<{
    contractId: `ct_${string}` | `nm_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | ChannelCreateTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelCreateTx;
}, "tag"> & Partial<Pick<{
    initiator: `ak_${string}`;
}, never>> & Omit<{
    initiator: `ak_${string}`;
}, never> & Partial<Pick<{
    initiatorAmount: Int;
}, never>> & Omit<{
    initiatorAmount: Int;
}, never> & Partial<Pick<{
    responder: `ak_${string}`;
}, never>> & Omit<{
    responder: `ak_${string}`;
}, never> & Partial<Pick<{
    responderAmount: Int;
}, never>> & Omit<{
    responderAmount: Int;
}, never> & Partial<Pick<{
    channelReserve: Int;
}, never>> & Omit<{
    channelReserve: Int;
}, never> & Partial<Pick<{
    lockPeriod: Int;
}, never>> & Omit<{
    lockPeriod: Int;
}, never> & Partial<Pick<{
    initiatorDelegateIds: string;
}, never>> & Omit<{
    initiatorDelegateIds: string;
}, never> & Partial<Pick<{
    responderDelegateIds: string;
}, never>> & Omit<{
    responderDelegateIds: string;
}, never> & Partial<Pick<{
    stateHash: `st_${string}`;
}, never>> & Omit<{
    stateHash: `st_${string}`;
}, never> & Partial<Pick<{
    channelId: `ch_${string}`;
}, never>> & Omit<{
    channelId: `ch_${string}`;
}, never> & Partial<Pick<{
    fromId: `ak_${string}`;
}, never>> & Omit<{
    fromId: `ak_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | ChannelDepositTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelDepositTx;
}, "tag"> & Partial<Pick<{
    amount: Int;
}, never>> & Omit<{
    amount: Int;
}, never> & Partial<Pick<{
    round: number;
}, never>> & Omit<{
    round: number;
}, never> & Partial<Pick<{
    tag: undefined | ChannelWithdrawTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelWithdrawTx;
}, "tag"> & Partial<Pick<{
    toId: `ak_${string}`;
}, never>> & Omit<{
    toId: `ak_${string}`;
}, never> & Partial<Pick<{
    payload: `tx_${string}`;
}, never>> & Omit<{
    payload: `tx_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | ChannelForceProgressTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelForceProgressTx;
}, "tag"> & Partial<Pick<{
    update: `cb_${string}`;
}, never>> & Omit<{
    update: `cb_${string}`;
}, never> & Partial<Pick<{
    offChainTrees: any;
}, "offChainTrees">> & Omit<{
    offChainTrees: any;
}, "offChainTrees"> & Partial<Pick<{
    tag: undefined | ChannelCloseMutualTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelCloseMutualTx;
}, "tag"> & Partial<Pick<{
    initiatorAmountFinal: Int;
}, never>> & Omit<{
    initiatorAmountFinal: Int;
}, never> & Partial<Pick<{
    responderAmountFinal: Int;
}, never>> & Omit<{
    responderAmountFinal: Int;
}, never> & Partial<Pick<{
    tag: undefined | TreesPoi;
}, "tag">> & Omit<{
    tag: undefined | TreesPoi;
}, "tag"> & Partial<Pick<{
    accounts: MPTree<AccountAddress, Account>[];
}, never>> & Omit<{
    accounts: MPTree<AccountAddress, Account>[];
}, never> & Partial<Pick<{
    calls: MPTree<Bytearray, ContractCall>[];
}, never>> & Omit<{
    calls: MPTree<Bytearray, ContractCall>[];
}, never> & Partial<Pick<{
    channels: MPTree<Channel, Channel>[];
}, never>> & Omit<{
    channels: MPTree<Channel, Channel>[];
}, never> & Partial<Pick<{
    contracts: MPTree<ContractAddress, Contract>[];
}, never>> & Omit<{
    contracts: MPTree<ContractAddress, Contract>[];
}, never> & Partial<Pick<{
    ns: MPTree<Name, Name>[];
}, never>> & Omit<{
    ns: MPTree<Name, Name>[];
}, never> & Partial<Pick<{
    oracles: MPTree<OracleAddress, Oracle>[];
}, never>> & Omit<{
    oracles: MPTree<OracleAddress, Oracle>[];
}, never> & Partial<Pick<{
    tag: undefined | ChannelCloseSoloTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelCloseSoloTx;
}, "tag"> & Partial<Pick<{
    poi: {
        tag: TreesPoi;
        version?: 1;
    } & Omit<Partial<Pick<({ version: 1 | undefined; }), "version">> & Omit<({ version: 1 | undefined; }), "version"> & Partial<Pick<({ tag: Tag.TreesPoi | undefined; }), "tag">> & Omit<({ tag: Tag.TreesPoi | undefined; }), "tag"> & Partial<Pick<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never>> & Omit<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never> & Partial<Pick<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never>> & Omit<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never> & Partial<Pick<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never>> & Omit<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never> & Partial<Pick<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never>> & Omit<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never> & Partial<Pick<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never>> & Omit<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never> & Partial<Pick<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>> & Omit<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>, "version" | "tag">;
}, never>> & Omit<{
    poi: {
        tag: TreesPoi;
        version?: 1;
    } & Omit<Partial<Pick<({ version: 1 | undefined; }), "version">> & Omit<({ version: 1 | undefined; }), "version"> & Partial<Pick<({ tag: Tag.TreesPoi | undefined; }), "tag">> & Omit<({ tag: Tag.TreesPoi | undefined; }), "tag"> & Partial<Pick<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never>> & Omit<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never> & Partial<Pick<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never>> & Omit<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never> & Partial<Pick<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never>> & Omit<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never> & Partial<Pick<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never>> & Omit<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never> & Partial<Pick<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never>> & Omit<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never> & Partial<Pick<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>> & Omit<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>, "version" | "tag">;
}, never> & Partial<Pick<{
    tag: undefined | ChannelSlashTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelSlashTx;
}, "tag"> & Partial<Pick<{
    tag: undefined | ChannelSettleTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelSettleTx;
}, "tag"> & Partial<Pick<{
    tag: undefined | ChannelOffChainTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelOffChainTx;
}, "tag"> & Partial<Pick<{
    tag: undefined | ChannelOffChainUpdateTransfer;
}, "tag">> & Omit<{
    tag: undefined | ChannelOffChainUpdateTransfer;
}, "tag"> & Partial<Pick<{
    from: `ak_${string}`;
}, never>> & Omit<{
    from: `ak_${string}`;
}, never> & Partial<Pick<{
    to: `ak_${string}`;
}, never>> & Omit<{
    to: `ak_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | ChannelOffChainUpdateDeposit;
}, "tag">> & Omit<{
    tag: undefined | ChannelOffChainUpdateDeposit;
}, "tag"> & Partial<Pick<{
    tag: undefined | ChannelOffChainUpdateWithdraw;
}, "tag">> & Omit<{
    tag: undefined | ChannelOffChainUpdateWithdraw;
}, "tag"> & Partial<Pick<{
    tag: undefined | ChannelOffChainUpdateCreateContract;
}, "tag">> & Omit<{
    tag: undefined | ChannelOffChainUpdateCreateContract;
}, "tag"> & Partial<Pick<{
    deposit: Int;
}, never>> & Omit<{
    deposit: Int;
}, never> & Partial<Pick<{
    tag: undefined | ChannelOffChainUpdateCallContract;
}, "tag">> & Omit<{
    tag: undefined | ChannelOffChainUpdateCallContract;
}, "tag"> & Partial<Pick<{
    caller: `ak_${string}`;
}, never>> & Omit<{
    caller: `ak_${string}`;
}, never> & Partial<Pick<{
    contract: `ct_${string}`;
}, never>> & Omit<{
    contract: `ct_${string}`;
}, never> & Partial<Pick<{
    callStack: any;
}, "callStack">> & Omit<{
    callStack: any;
}, "callStack"> & Partial<Pick<{
    tag: undefined | ChannelClientReconnectTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelClientReconnectTx;
}, "tag"> & Partial<Pick<{
    role: string;
}, never>> & Omit<{
    role: string;
}, never> & Partial<Pick<{
    pubkey: `ak_${string}`;
}, never>> & Omit<{
    pubkey: `ak_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | Channel;
}, "tag">> & Omit<{
    tag: undefined | Channel;
}, "tag"> & Partial<Pick<{
    version: undefined | 3;
}, "version">> & Omit<{
    version: undefined | 3;
}, "version"> & Partial<Pick<{
    channelAmount: Int;
}, never>> & Omit<{
    channelAmount: Int;
}, never> & Partial<Pick<{
    initiatorDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
}, never>> & Omit<{
    initiatorDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
}, never> & Partial<Pick<{
    responderDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
}, never>> & Omit<{
    responderDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
}, never> & Partial<Pick<{
    stateHash: string;
}, never>> & Omit<{
    stateHash: string;
}, never> & Partial<Pick<{
    soloRound: Int;
}, never>> & Omit<{
    soloRound: Int;
}, never> & Partial<Pick<{
    lockedUntil: Int;
}, never>> & Omit<{
    lockedUntil: Int;
}, never> & Partial<Pick<{
    initiatorAuth: `cb_${string}`;
}, never>> & Omit<{
    initiatorAuth: `cb_${string}`;
}, never> & Partial<Pick<{
    responderAuth: `cb_${string}`;
}, never>> & Omit<{
    responderAuth: `cb_${string}`;
}, never> & Partial<Pick<{
    tag: undefined | ChannelSnapshotSoloTx;
}, "tag">> & Omit<{
    tag: undefined | ChannelSnapshotSoloTx;
}, "tag"> & Partial<Pick<{
    tag: undefined | StateTrees;
}, "tag">> & Omit<{
    tag: undefined | StateTrees;
}, "tag"> & Partial<Pick<{
    contracts: any;
}, "contracts">> & Omit<{
    contracts: any;
}, "contracts"> & Partial<Pick<{
    calls: any;
}, "calls">> & Omit<{
    calls: any;
}, "calls"> & Partial<Pick<{
    channels: any;
}, "channels">> & Omit<{
    channels: any;
}, "channels"> & Partial<Pick<{
    ns: any;
}, "ns">> & Omit<{
    ns: any;
}, "ns"> & Partial<Pick<{
    oracles: any;
}, "oracles">> & Omit<{
    oracles: any;
}, "oracles"> & Partial<Pick<{
    accounts: any;
}, "accounts">> & Omit<{
    accounts: any;
}, "accounts"> & Partial<Pick<{
    tag: undefined | Mtree;
}, "tag">> & Omit<{
    tag: undefined | Mtree;
}, "tag"> & Partial<Pick<{
    values: any[];
}, never>> & Omit<{
    values: any[];
}, never> & Partial<Pick<{
    tag: undefined | MtreeValue;
}, "tag">> & Omit<{
    tag: undefined | MtreeValue;
}, "tag"> & Partial<Pick<{
    key: string;
}, never>> & Omit<{
    key: string;
}, never> & Partial<Pick<{
    value: Uint8Array;
}, never>> & Omit<{
    value: Uint8Array;
}, never> & Partial<Pick<{
    tag: undefined | ContractsMtree;
}, "tag">> & Omit<{
    tag: undefined | ContractsMtree;
}, "tag"> & Partial<Pick<{
    tag: undefined | CallsMtree;
}, "tag">> & Omit<{
    tag: undefined | CallsMtree;
}, "tag"> & Partial<Pick<{
    tag: undefined | ChannelsMtree;
}, "tag">> & Omit<{
    tag: undefined | ChannelsMtree;
}, "tag"> & Partial<Pick<{
    tag: undefined | NameserviceMtree;
}, "tag">> & Omit<{
    tag: undefined | NameserviceMtree;
}, "tag"> & Partial<Pick<{
    mtree: any;
}, "mtree">> & Omit<{
    mtree: any;
}, "mtree"> & Partial<Pick<{
    tag: undefined | OraclesMtree;
}, "tag">> & Omit<{
    tag: undefined | OraclesMtree;
}, "tag"> & Partial<Pick<{
    otree: any;
}, "otree">> & Omit<{
    otree: any;
}, "otree"> & Partial<Pick<{
    tag: undefined | AccountsMtree;
}, "tag">> & Omit<{
    tag: undefined | AccountsMtree;
}, "tag"> & Partial<Pick<{
    tag: undefined | CompilerSophia;
}, "tag">> & Omit<{
    tag: undefined | CompilerSophia;
}, "tag"> & Partial<Pick<{
    sourceCodeHash: Uint8Array;
}, never>> & Omit<{
    sourceCodeHash: Uint8Array;
}, never> & Partial<Pick<{
    typeInfo: any;
}, "typeInfo">> & Omit<{
    typeInfo: any;
}, "typeInfo"> & Partial<Pick<{
    byteCode: Uint8Array;
}, never>> & Omit<{
    byteCode: Uint8Array;
}, never> & Partial<Pick<{
    compilerVersion: string;
}, never>> & Omit<{
    compilerVersion: string;
}, never> & Partial<Pick<{
    payable: Boolean;
}, never>> & Omit<{
    payable: Boolean;
}, never> & Partial<Pick<{
    tag: undefined | GaAttachTx;
}, "tag">> & Omit<{
    tag: undefined | GaAttachTx;
}, "tag"> & Partial<Pick<{
    authFun: Uint8Array;
}, never>> & Omit<{
    authFun: Uint8Array;
}, never> & Partial<Pick<{
    tag: undefined | GaMetaTx;
}, "tag">> & Omit<{
    tag: undefined | GaMetaTx;
}, "tag"> & Partial<Pick<{
    gaId: `ak_${string}`;
}, never>> & Omit<{
    gaId: `ak_${string}`;
}, never> & Partial<Pick<{
    authData: `cb_${string}`;
}, never>> & Omit<{
    authData: `cb_${string}`;
}, never> & Partial<Pick<{
    tx: any;
}, "tx">> & Omit<{
    tx: any;
}, "tx"> & Partial<Pick<{
    tag: undefined | PayingForTx;
}, "tag">> & Omit<{
    tag: undefined | PayingForTx;
}, "tag"> & Partial<Pick<{
    payerId: `ak_${string}`;
}, never>> & Omit<{
    payerId: `ak_${string}`;
}, never>>, "nonce" | "ttl">, "senderId"> & (TxType extends OracleResponseTx | OracleExtendTx ? {
    callerId: `ak_${string}`;
} : {}) & (TxType extends ContractCreateTx | GaAttachTx ? {
    ctVersion?: CtVersion;
} : {}) & (TxType extends OracleRegisterTx | ContractCallTx ? {
    abiVersion?: ABI_VERSIONS;
} : {}), "onNode"> & {
    onNode?: Node;
}): Promise<`tx_${string}`>
Type Parameters
- TxType extends Tag
Parameters
- txType: TxType
- options: Omit<Omit<{
      tag: TxType;
      version?: Extract<KeysOfUnion<{
          10: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Account);
                  serialize: ((value?: Account) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["balance", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Account);
                  serialize: ((value?: Account) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["flags", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["balance", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["gaContract", {
                  deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                  serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["gaAuthFun", binary, ContractBytearray]];
          };
          11: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => SignedTx);
                  serialize: ((value?: SignedTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["signatures", signatures], readonly ["encodedTx", rlpBinary]];
          };
          12: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => SpendTx);
                  serialize: ((value?: SpendTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["senderId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["recipientId", {
                  deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                  serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["payload", payload]];
          };
          20: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Oracle);
                  serialize: ((value?: Oracle) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }]];
          };
          22: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleRegisterTx);
                  serialize: ((value?: OracleRegisterTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["oracleTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }]];
          };
          23: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleQueryTx);
                  serialize: ((value?: OracleQueryTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["senderId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                  serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["query", string], readonly ["queryFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["queryTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["queryTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["responseTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["responseTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          24: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleResponseTx);
                  serialize: ((value?: OracleResponseTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}`);
                  serialize: ((value: `ok_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["queryId", binary, OracleQueryId], readonly ["response", string], readonly ["responseTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["responseTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          25: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OracleExtendTx);
                  serialize: ((value?: OracleExtendTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["oracleId", {
                  deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
                  serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["oracleTtlType", {
                  deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
                  serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
              }], readonly ["oracleTtlValue", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          30: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Name);
                  serialize: ((value?: Name) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nameTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["status", binary], readonly ["clientTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["pointers", {
                  deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                  serialize(pointers: NamePointer[]): Buffer[][];
              }]];
          };
          32: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameClaimTx);
                  serialize: ((value?: NameClaimTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["name", {
                  deserialize(value: Buffer): `${string}.chain`;
                  serialize(value: `${string}.chain`): Buffer;
              }], readonly ["nameSalt", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["nameFee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, txFields: {
                      name: `${string}.chain`;
                  } & Options): Buffer;
                  serializeAettos(_value: undefined | string, txFields: {
                      name: `${string}.chain`;
                  }): string;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          33: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NamePreclaimTx);
                  serialize: ((value?: NamePreclaimTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["commitmentId", {
                  deserialize: ((value: Buffer) => `cm_${string}`);
                  serialize: ((value: `cm_${string}`) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          34: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameUpdateTx);
                  serialize: ((value?: NameUpdateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["nameTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["pointers", {
                  deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
                  serialize(pointers: NamePointer[]): Buffer[][];
              }], readonly ["clientTtl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          35: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameRevokeTx);
                  serialize: ((value?: NameRevokeTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          36: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameTransferTx);
                  serialize: ((value?: NameTransferTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accountId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nameId", {
                  deserialize: ((value: Buffer) => `nm_${string}`);
                  serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
              }], readonly ["recipientId", {
                  deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
                  serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          40: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Contract);
                  serialize: ((value?: Contract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["owner", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["log", binary, ContractBytearray], readonly ["active", bool], readonly ["referers", {
                  deserialize: ((value: Buffer[]) => `ak_${string}`[]);
                  serialize: ((value: `ak_${string}`[]) => Buffer[]);
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, options: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }]];
          };
          41: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCall);
                  serialize: ((value?: ContractCall) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["callerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["callerNonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["height", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["contractId", {
                  deserialize: ((value: Buffer) => `ct_${string}`);
                  serialize: ((value: `ct_${string}`) => Buffer);
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["gasUsed", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["returnValue", binary, ContractBytearray], readonly ["returnType", {
                  deserialize: ((value: Buffer) => CallReturnType);
                  serialize: ((value: CallReturnType) => Buffer);
              }], readonly ["log", rawBinary]];
          };
          42: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCreateTx);
                  serialize: ((value?: ContractCreateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["ownerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["code", binary, ContractBytearray], readonly ["ctVersion", ctVersion], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, options: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", binary, ContractBytearray]];
          };
          43: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractCallTx);
                  serialize: ((value?: ContractCallTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["callerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["contractId", {
                  deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
                  serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", binary, ContractBytearray]];
          };
          50: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCreateTx);
                  serialize: ((value?: ChannelCreateTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["initiator", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responder", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["responderAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["channelReserve", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockPeriod", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["initiatorDelegateIds", string], readonly ["responderDelegateIds", string], readonly ["stateHash", binary, State], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          51: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelDepositTx);
                  serialize: ((value?: ChannelDepositTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["stateHash", binary, State], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          52: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelWithdrawTx);
                  serialize: ((value?: ChannelWithdrawTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["toId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["stateHash", binary, State], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          521: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelForceProgressTx);
                  serialize: ((value?: ChannelForceProgressTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", binary, Transaction], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["update", binary, ContractBytearray], readonly ["stateHash", binary, State], readonly ["offChainTrees", stateTree], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          53: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCloseMutualTx);
                  serialize: ((value?: ChannelCloseMutualTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          54: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelCloseSoloTx);
                  serialize: ((value?: ChannelCloseSoloTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", binary, Transaction], readonly ["poi", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => TxUnpacked<Partial<Pick<{
                      version: undefined | 1;
                  }, "version">> & Omit<{
                      version: undefined | 1;
                  }, "version"> & Partial<Pick<{
                      tag: undefined | TreesPoi;
                  }, "tag">> & Omit<{
                      tag: undefined | TreesPoi;
                  }, "tag"> & Partial<Pick<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never>> & Omit<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never> & Partial<Pick<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never>> & Omit<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never> & Partial<Pick<{
                      channels: MPTree<Channel, Channel>[];
                  }, never>> & Omit<{
                      channels: MPTree<Channel, Channel>[];
                  }, never> & Partial<Pick<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never>> & Omit<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never> & Partial<Pick<{
                      ns: MPTree<Name, Name>[];
                  }, never>> & Omit<{
                      ns: MPTree<Name, Name>[];
                  }, never> & Partial<Pick<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>> & Omit<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>>);
                  serialize: ((value: ({ tag: Tag.TreesPoi; version?: 1 | undefined; }) & Omit<Partial<Pick<{
                      version: undefined | 1;
                  }, "version">> & Omit<{
                      version: undefined | 1;
                  }, "version"> & Partial<Pick<{
                      tag: undefined | TreesPoi;
                  }, "tag">> & Omit<{
                      tag: undefined | TreesPoi;
                  }, "tag"> & Partial<Pick<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never>> & Omit<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never> & Partial<Pick<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never>> & Omit<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never> & Partial<Pick<{
                      channels: MPTree<Channel, Channel>[];
                  }, never>> & Omit<{
                      channels: MPTree<Channel, Channel>[];
                  }, never> & Partial<Pick<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never>> & Omit<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never> & Partial<Pick<{
                      ns: MPTree<Name, Name>[];
                  }, never>> & Omit<{
                      ns: MPTree<Name, Name>[];
                  }, never> & Partial<Pick<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>> & Omit<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>, "version" | "tag">, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          55: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSlashTx);
                  serialize: ((value?: ChannelSlashTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", binary, Transaction], readonly ["poi", {
                  deserialize: ((value: Buffer, options: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => TxUnpacked<Partial<Pick<{
                      version: undefined | 1;
                  }, "version">> & Omit<{
                      version: undefined | 1;
                  }, "version"> & Partial<Pick<{
                      tag: undefined | TreesPoi;
                  }, "tag">> & Omit<{
                      tag: undefined | TreesPoi;
                  }, "tag"> & Partial<Pick<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never>> & Omit<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never> & Partial<Pick<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never>> & Omit<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never> & Partial<Pick<{
                      channels: MPTree<Channel, Channel>[];
                  }, never>> & Omit<{
                      channels: MPTree<Channel, Channel>[];
                  }, never> & Partial<Pick<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never>> & Omit<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never> & Partial<Pick<{
                      ns: MPTree<Name, Name>[];
                  }, never>> & Omit<{
                      ns: MPTree<Name, Name>[];
                  }, never> & Partial<Pick<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>> & Omit<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>>);
                  serialize: ((value: ({ tag: Tag.TreesPoi; version?: 1 | undefined; }) & Omit<Partial<Pick<{
                      version: undefined | 1;
                  }, "version">> & Omit<{
                      version: undefined | 1;
                  }, "version"> & Partial<Pick<{
                      tag: undefined | TreesPoi;
                  }, "tag">> & Omit<{
                      tag: undefined | TreesPoi;
                  }, "tag"> & Partial<Pick<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never>> & Omit<{
                      accounts: MPTree<AccountAddress, Account>[];
                  }, never> & Partial<Pick<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never>> & Omit<{
                      calls: MPTree<Bytearray, ContractCall>[];
                  }, never> & Partial<Pick<{
                      channels: MPTree<Channel, Channel>[];
                  }, never>> & Omit<{
                      channels: MPTree<Channel, Channel>[];
                  }, never> & Partial<Pick<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never>> & Omit<{
                      contracts: MPTree<ContractAddress, Contract>[];
                  }, never> & Partial<Pick<{
                      ns: MPTree<Name, Name>[];
                  }, never>> & Omit<{
                      ns: MPTree<Name, Name>[];
                  }, never> & Partial<Pick<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>> & Omit<{
                      oracles: MPTree<OracleAddress, Oracle>[];
                  }, never>, "version" | "tag">, options: {
                      buildTx: (<TxType, E, Version>(params: ({ tag: TxType; version?: Version | undefined; }) & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                          gasMax?: number;
                      } : {}), options?: {
                          denomination?: AE_AMOUNT_FORMATS;
                          prefix?: E;
                      }) => Generic<E>);
                  }) => Buffer);
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          56: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSettleTx);
                  serialize: ((value?: ChannelSettleTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["initiatorAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmountFinal", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          57: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainTx);
                  serialize: ((value?: ChannelOffChainTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["stateHash", binary, State]];
          };
          570: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
                  serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["to", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          571: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
                  serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          572: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
                  serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["from", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }]];
          };
          573: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
                  serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["owner", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["deposit", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["callData", binary, ContractBytearray]];
          };
          574: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
                  serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["caller", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["contract", {
                  deserialize: ((value: Buffer) => `ct_${string}`);
                  serialize: ((value: `ct_${string}`) => Buffer);
              }], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }], readonly ["amount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["callData", binary, ContractBytearray], readonly ["callStack", callStack], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }]];
          };
          575: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelClientReconnectTx);
                  serialize: ((value?: ChannelClientReconnectTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["role", string], readonly ["pubkey", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }]];
          };
          58: {
              3: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Channel);
                  serialize: ((value?: Channel) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 3);
                  serialize: ((value?: 3) => Buffer);
              }], readonly ["initiator", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["responder", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["channelAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["responderAmount", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["channelReserve", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorDelegateIds", {
                  deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
              }], readonly ["responderDelegateIds", {
                  deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
                  serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
              }], readonly ["stateHash", hex], readonly ["round", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["soloRound", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockPeriod", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["lockedUntil", {
                  deserialize(value: Buffer): string;
                  serialize(value: Int): Buffer;
              }], readonly ["initiatorAuth", binary, ContractBytearray], readonly ["responderAuth", binary, ContractBytearray]];
          };
          59: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
                  serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channelId", {
                  deserialize: ((value: Buffer) => `ch_${string}`);
                  serialize: ((value: `ch_${string}`) => Buffer);
              }], readonly ["fromId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["payload", binary, Transaction], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }]];
          };
          60: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => TreesPoi);
                  serialize: ((value?: TreesPoi) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accounts", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<AccountAddress, Account>[]);
                  serialize: ((value: MPTree<AccountAddress, Account>[]) => MPTreeBinary[]);
              }], readonly ["calls", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<Bytearray, ContractCall>[]);
                  serialize: ((value: MPTree<Bytearray, ContractCall>[]) => MPTreeBinary[]);
              }], readonly ["channels", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<Channel, Channel>[]);
                  serialize: ((value: MPTree<Channel, Channel>[]) => MPTreeBinary[]);
              }], readonly ["contracts", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<ContractAddress, Contract>[]);
                  serialize: ((value: MPTree<ContractAddress, Contract>[]) => MPTreeBinary[]);
              }], readonly ["ns", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<Name, Name>[]);
                  serialize: ((value: MPTree<Name, Name>[]) => MPTreeBinary[]);
              }], readonly ["oracles", {
                  deserialize: ((value: MPTreeBinary[], o: {
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }) => MPTree<OracleAddress, Oracle>[]);
                  serialize: ((value: MPTree<OracleAddress, Oracle>[]) => MPTreeBinary[]);
              }]];
          };
          62: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => StateTrees);
                  serialize: ((value?: StateTrees) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["contracts", rlpBinary], readonly ["calls", rlpBinary], readonly ["channels", rlpBinary], readonly ["ns", rlpBinary], readonly ["oracles", rlpBinary], readonly ["accounts", rlpBinary]];
          };
          621: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ContractsMtree);
                  serialize: ((value?: ContractsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["contracts", rlpBinary]];
          };
          622: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => CallsMtree);
                  serialize: ((value?: CallsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["calls", rlpBinary]];
          };
          623: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => ChannelsMtree);
                  serialize: ((value?: ChannelsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["channels", rlpBinary]];
          };
          624: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => NameserviceMtree);
                  serialize: ((value?: NameserviceMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["mtree", rlpBinary]];
          };
          625: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => OraclesMtree);
                  serialize: ((value?: OraclesMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["otree", rlpBinary]];
          };
          626: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => AccountsMtree);
                  serialize: ((value?: AccountsMtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["accounts", rlpBinary]];
          };
          63: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => Mtree);
                  serialize: ((value?: Mtree) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["values", rlpBinaries]];
          };
          64: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => MtreeValue);
                  serialize: ((value?: MtreeValue) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["key", hex], readonly ["value", rawBinary]];
          };
          70: {
              3: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => CompilerSophia);
                  serialize: ((value?: CompilerSophia) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 3);
                  serialize: ((value?: 3) => Buffer);
              }], readonly ["sourceCodeHash", rawBinary], readonly ["typeInfo", sophiaCodeTypeInfo], readonly ["byteCode", rawBinary], readonly ["compilerVersion", string], readonly ["payable", bool]];
          };
          80: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => GaAttachTx);
                  serialize: ((value?: GaAttachTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["ownerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["code", binary, ContractBytearray], readonly ["authFun", rawBinary], readonly ["ctVersion", ctVersion], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["ttl", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["callData", binary, ContractBytearray]];
          };
          81: {
              2: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => GaMetaTx);
                  serialize: ((value?: GaMetaTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 2);
                  serialize: ((value?: 2) => Buffer);
              }], readonly ["gaId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["authData", binary, ContractBytearray], readonly ["abiVersion", {
                  deserialize: ((value: Buffer) => ABI_VERSIONS);
                  serialize: ((value: ABI_VERSIONS) => Buffer);
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["gasLimit", {
                  deserialize(value: Buffer): number;
                  serialize(_value: undefined | number, __namedParameters: {
                      _computingGasLimit?: number;
                      gasMax: number;
                      rebuildTx: ((params: any) => any);
                      tag: Tag;
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): Buffer;
              }], readonly ["gasPrice", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(value?: undefined | string): string;
              }], readonly ["tx", rlpBinary]];
          };
          82: {
              1: readonly [readonly ["tag", {
                  deserialize: ((value: Buffer) => PayingForTx);
                  serialize: ((value?: PayingForTx) => Buffer);
              }], readonly ["version", {
                  deserialize: ((value: Buffer) => 1);
                  serialize: ((value?: 1) => Buffer);
              }], readonly ["payerId", {
                  deserialize: ((value: Buffer) => `ak_${string}`);
                  serialize: ((value: `ak_${string}`) => Buffer);
              }], readonly ["nonce", {
                  deserialize(value: Buffer): number;
                  serialize(value: number): Buffer;
              }], readonly ["fee", {
                  deserialize(value: Buffer): string;
                  serialize(value: undefined | Int, __namedParameters: Options): Buffer;
                  serializeAettos(_value: undefined | string, __namedParameters: {
                      _computingMinFee?: BigNumber;
                      _pickBiggerFee?: boolean;
                      rebuildTx: ((params: any) => `tx_${string}`);
                      unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
                  }): string;
              }], readonly ["tx", rlpBinary]];
          };
      }[TxType]>, number>;
  } & Omit<TxTypeSchemaBy<TxType, Extract<KeysOfUnion<{
      10: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Account);
              serialize: ((value?: Account) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["balance", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }]];
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Account);
              serialize: ((value?: Account) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["flags", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["balance", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["gaContract", {
              deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
              serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["gaAuthFun", binary, ContractBytearray]];
      };
      11: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => SignedTx);
              serialize: ((value?: SignedTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["signatures", signatures], readonly ["encodedTx", rlpBinary]];
      };
      12: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => SpendTx);
              serialize: ((value?: SpendTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["senderId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["recipientId", {
              deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
              serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["payload", payload]];
      };
      20: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Oracle);
              serialize: ((value?: Oracle) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["oracleTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["abiVersion", {
              deserialize: ((value: Buffer) => ABI_VERSIONS);
              serialize: ((value: ABI_VERSIONS) => Buffer);
          }]];
      };
      22: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OracleRegisterTx);
              serialize: ((value?: OracleRegisterTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["queryFormat", string], readonly ["responseFormat", string], readonly ["queryFee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["oracleTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["oracleTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["abiVersion", {
              deserialize: ((value: Buffer) => ABI_VERSIONS);
              serialize: ((value: ABI_VERSIONS) => Buffer);
          }]];
      };
      23: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OracleQueryTx);
              serialize: ((value?: OracleQueryTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["senderId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["oracleId", {
              deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
              serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["query", string], readonly ["queryFee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["queryTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["queryTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["responseTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["responseTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      24: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OracleResponseTx);
              serialize: ((value?: OracleResponseTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["oracleId", {
              deserialize: ((value: Buffer) => `ok_${string}`);
              serialize: ((value: `ok_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["queryId", binary, OracleQueryId], readonly ["response", string], readonly ["responseTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["responseTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      25: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OracleExtendTx);
              serialize: ((value?: OracleExtendTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["oracleId", {
              deserialize: ((value: Buffer) => `ok_${string}` | `nm_${string}`);
              serialize: ((value: `ok_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["oracleTtlType", {
              deserialize: ((value: Buffer) => ORACLE_TTL_TYPES);
              serialize: ((value: ORACLE_TTL_TYPES) => Buffer);
          }], readonly ["oracleTtlValue", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      30: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Name);
              serialize: ((value?: Name) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nameTtl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["status", binary], readonly ["clientTtl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["pointers", {
              deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
              serialize(pointers: NamePointer[]): Buffer[][];
          }]];
      };
      32: {
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameClaimTx);
              serialize: ((value?: NameClaimTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["name", {
              deserialize(value: Buffer): `${string}.chain`;
              serialize(value: `${string}.chain`): Buffer;
          }], readonly ["nameSalt", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["nameFee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, txFields: {
                  name: `${string}.chain`;
              } & Options): Buffer;
              serializeAettos(_value: undefined | string, txFields: {
                  name: `${string}.chain`;
              }): string;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      33: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NamePreclaimTx);
              serialize: ((value?: NamePreclaimTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["commitmentId", {
              deserialize: ((value: Buffer) => `cm_${string}`);
              serialize: ((value: `cm_${string}`) => Buffer);
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      34: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameUpdateTx);
              serialize: ((value?: NameUpdateTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nameId", {
              deserialize: ((value: Buffer) => `nm_${string}`);
              serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
          }], readonly ["nameTtl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["pointers", {
              deserialize(pointers: [key: Buffer, id: Buffer][]): NamePointer[];
              serialize(pointers: NamePointer[]): Buffer[][];
          }], readonly ["clientTtl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      35: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameRevokeTx);
              serialize: ((value?: NameRevokeTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nameId", {
              deserialize: ((value: Buffer) => `nm_${string}`);
              serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      36: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameTransferTx);
              serialize: ((value?: NameTransferTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accountId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nameId", {
              deserialize: ((value: Buffer) => `nm_${string}`);
              serialize(value: `${string}.chain` | `nm_${string}`): Buffer;
          }], readonly ["recipientId", {
              deserialize: ((value: Buffer) => `ak_${string}` | `nm_${string}`);
              serialize: ((value: `ak_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      40: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Contract);
              serialize: ((value?: Contract) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["owner", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["log", binary, ContractBytearray], readonly ["active", bool], readonly ["referers", {
              deserialize: ((value: Buffer[]) => `ak_${string}`[]);
              serialize: ((value: `ak_${string}`[]) => Buffer[]);
          }], readonly ["deposit", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, options: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }]];
      };
      41: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ContractCall);
              serialize: ((value?: ContractCall) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["callerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["callerNonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["height", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["contractId", {
              deserialize: ((value: Buffer) => `ct_${string}`);
              serialize: ((value: `ct_${string}`) => Buffer);
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["gasUsed", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["returnValue", binary, ContractBytearray], readonly ["returnType", {
              deserialize: ((value: Buffer) => CallReturnType);
              serialize: ((value: CallReturnType) => Buffer);
          }], readonly ["log", rawBinary]];
      };
      42: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ContractCreateTx);
              serialize: ((value?: ContractCreateTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["ownerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["code", binary, ContractBytearray], readonly ["ctVersion", ctVersion], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["deposit", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, options: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): Buffer;
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["callData", binary, ContractBytearray]];
      };
      43: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ContractCallTx);
              serialize: ((value?: ContractCallTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["callerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["contractId", {
              deserialize: ((value: Buffer) => `ct_${string}` | `nm_${string}`);
              serialize: ((value: `ct_${string}` | `nm_${string}`) => Buffer);
          }], readonly ["abiVersion", {
              deserialize: ((value: Buffer) => ABI_VERSIONS);
              serialize: ((value: ABI_VERSIONS) => Buffer);
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value: undefined | string): string;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): Buffer;
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["callData", binary, ContractBytearray]];
      };
      50: {
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelCreateTx);
              serialize: ((value?: ChannelCreateTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["initiator", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["initiatorAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["responder", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["responderAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["channelReserve", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["lockPeriod", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["initiatorDelegateIds", string], readonly ["responderDelegateIds", string], readonly ["stateHash", binary, State], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      51: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelDepositTx);
              serialize: ((value?: ChannelDepositTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["stateHash", binary, State], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      52: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelWithdrawTx);
              serialize: ((value?: ChannelWithdrawTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["toId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["stateHash", binary, State], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      521: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelForceProgressTx);
              serialize: ((value?: ChannelForceProgressTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["payload", binary, Transaction], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["update", binary, ContractBytearray], readonly ["stateHash", binary, State], readonly ["offChainTrees", stateTree], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      53: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelCloseMutualTx);
              serialize: ((value?: ChannelCloseMutualTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["initiatorAmountFinal", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["responderAmountFinal", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      54: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelCloseSoloTx);
              serialize: ((value?: ChannelCloseSoloTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["payload", binary, Transaction], readonly ["poi", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }) => TxUnpacked<Partial<Pick<{
                  version: undefined | 1;
              }, "version">> & Omit<{
                  version: undefined | 1;
              }, "version"> & Partial<Pick<{
                  tag: undefined | TreesPoi;
              }, "tag">> & Omit<{
                  tag: undefined | TreesPoi;
              }, "tag"> & Partial<Pick<{
                  accounts: MPTree<AccountAddress, Account>[];
              }, never>> & Omit<{
                  accounts: MPTree<AccountAddress, Account>[];
              }, never> & Partial<Pick<{
                  calls: MPTree<Bytearray, ContractCall>[];
              }, never>> & Omit<{
                  calls: MPTree<Bytearray, ContractCall>[];
              }, never> & Partial<Pick<{
                  channels: MPTree<Channel, Channel>[];
              }, never>> & Omit<{
                  channels: MPTree<Channel, Channel>[];
              }, never> & Partial<Pick<{
                  contracts: MPTree<ContractAddress, Contract>[];
              }, never>> & Omit<{
                  contracts: MPTree<ContractAddress, Contract>[];
              }, never> & Partial<Pick<{
                  ns: MPTree<Name, Name>[];
              }, never>> & Omit<{
                  ns: MPTree<Name, Name>[];
              }, never> & Partial<Pick<{
                  oracles: MPTree<OracleAddress, Oracle>[];
              }, never>> & Omit<{
                  oracles: MPTree<OracleAddress, Oracle>[];
              }, never>>);
              serialize: ((value: {
                  tag: TreesPoi;
                  version?: 1;
              } & Omit<Partial<Pick<{
                  version: undefined | 1;
              }, "version">> & Omit<{
                  version: undefined | 1;
              }, "version"> & Partial<Pick<{
                  tag: undefined | TreesPoi;
              }, "tag">> & Omit<{
                  tag: undefined | TreesPoi;
              }, "tag"> & Partial<Pick<{
                  accounts: MPTree<AccountAddress, Account>[];
              }, never>> & Omit<{
                  accounts: MPTree<AccountAddress, Account>[];
              }, never> & Partial<Pick<{
                  calls: MPTree<Bytearray, ContractCall>[];
              }, never>> & Omit<{
                  calls: MPTree<Bytearray, ContractCall>[];
              }, never> & Partial<Pick<{
                  channels: MPTree<Channel, Channel>[];
              }, never>> & Omit<{
                  channels: MPTree<Channel, Channel>[];
              }, never> & Partial<Pick<{
                  contracts: MPTree<ContractAddress, Contract>[];
              }, never>> & Omit<{
                  contracts: MPTree<ContractAddress, Contract>[];
              }, never> & Partial<Pick<{
                  ns: MPTree<Name, Name>[];
              }, never>> & Omit<{
                  ns: MPTree<Name, Name>[];
              }, never> & Partial<Pick<{
                  oracles: MPTree<OracleAddress, Oracle>[];
              }, never>> & Omit<{
                  oracles: MPTree<OracleAddress, Oracle>[];
              }, never>, "version" | "tag">, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      55: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelSlashTx);
              serialize: ((value?: ChannelSlashTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["payload", binary, Transaction], readonly ["poi", {
              deserialize: ((value: Buffer, options: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }) => TxUnpacked<Partial<Pick<{
                  version: undefined | 1;
              }, "version">> & Omit<{
                  version: undefined | 1;
              }, "version"> & Partial<Pick<{
                  tag: undefined | TreesPoi;
              }, "tag">> & Omit<{
                  tag: undefined | TreesPoi;
              }, "tag"> & Partial<Pick<{
                  accounts: MPTree<AccountAddress, Account>[];
              }, never>> & Omit<{
                  accounts: MPTree<AccountAddress, Account>[];
              }, never> & Partial<Pick<{
                  calls: MPTree<Bytearray, ContractCall>[];
              }, never>> & Omit<{
                  calls: MPTree<Bytearray, ContractCall>[];
              }, never> & Partial<Pick<{
                  channels: MPTree<Channel, Channel>[];
              }, never>> & Omit<{
                  channels: MPTree<Channel, Channel>[];
              }, never> & Partial<Pick<{
                  contracts: MPTree<ContractAddress, Contract>[];
              }, never>> & Omit<{
                  contracts: MPTree<ContractAddress, Contract>[];
              }, never> & Partial<Pick<{
                  ns: MPTree<Name, Name>[];
              }, never>> & Omit<{
                  ns: MPTree<Name, Name>[];
              }, never> & Partial<Pick<{
                  oracles: MPTree<OracleAddress, Oracle>[];
              }, never>> & Omit<{
                  oracles: MPTree<OracleAddress, Oracle>[];
              }, never>>);
              serialize: ((value: {
                  tag: TreesPoi;
                  version?: 1;
              } & Omit<Partial<Pick<{
                  version: undefined | 1;
              }, "version">> & Omit<{
                  version: undefined | 1;
              }, "version"> & Partial<Pick<{
                  tag: undefined | TreesPoi;
              }, "tag">> & Omit<{
                  tag: undefined | TreesPoi;
              }, "tag"> & Partial<Pick<{
                  accounts: MPTree<AccountAddress, Account>[];
              }, never>> & Omit<{
                  accounts: MPTree<AccountAddress, Account>[];
              }, never> & Partial<Pick<{
                  calls: MPTree<Bytearray, ContractCall>[];
              }, never>> & Omit<{
                  calls: MPTree<Bytearray, ContractCall>[];
              }, never> & Partial<Pick<{
                  channels: MPTree<Channel, Channel>[];
              }, never>> & Omit<{
                  channels: MPTree<Channel, Channel>[];
              }, never> & Partial<Pick<{
                  contracts: MPTree<ContractAddress, Contract>[];
              }, never>> & Omit<{
                  contracts: MPTree<ContractAddress, Contract>[];
              }, never> & Partial<Pick<{
                  ns: MPTree<Name, Name>[];
              }, never>> & Omit<{
                  ns: MPTree<Name, Name>[];
              }, never> & Partial<Pick<{
                  oracles: MPTree<OracleAddress, Oracle>[];
              }, never>> & Omit<{
                  oracles: MPTree<OracleAddress, Oracle>[];
              }, never>, "version" | "tag">, options: {
                  buildTx: (<TxType, E, Version>(params: {
                      tag: TxType;
                      version?: Version;
                  } & Omit<TxTypeSchemaBy<TxType, Version>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
                      gasMax?: number;
                  } : {}), options?: {
                      denomination?: AE_AMOUNT_FORMATS;
                      prefix?: E;
                  }) => Generic<E>);
              }) => Buffer);
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      56: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelSettleTx);
              serialize: ((value?: ChannelSettleTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["initiatorAmountFinal", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["responderAmountFinal", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      57: {
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainTx);
              serialize: ((value?: ChannelOffChainTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["stateHash", binary, State]];
      };
      570: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateTransfer);
              serialize: ((value?: ChannelOffChainUpdateTransfer) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["from", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["to", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }]];
      };
      571: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateDeposit);
              serialize: ((value?: ChannelOffChainUpdateDeposit) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["from", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }]];
      };
      572: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateWithdraw);
              serialize: ((value?: ChannelOffChainUpdateWithdraw) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["from", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }]];
      };
      573: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateCreateContract);
              serialize: ((value?: ChannelOffChainUpdateCreateContract) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["owner", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["ctVersion", ctVersion], readonly ["code", binary, ContractBytearray], readonly ["deposit", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["callData", binary, ContractBytearray]];
      };
      574: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelOffChainUpdateCallContract);
              serialize: ((value?: ChannelOffChainUpdateCallContract) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["caller", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["contract", {
              deserialize: ((value: Buffer) => `ct_${string}`);
              serialize: ((value: `ct_${string}`) => Buffer);
          }], readonly ["abiVersion", {
              deserialize: ((value: Buffer) => ABI_VERSIONS);
              serialize: ((value: ABI_VERSIONS) => Buffer);
          }], readonly ["amount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["callData", binary, ContractBytearray], readonly ["callStack", callStack], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): Buffer;
          }]];
      };
      575: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelClientReconnectTx);
              serialize: ((value?: ChannelClientReconnectTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["role", string], readonly ["pubkey", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }]];
      };
      58: {
          3: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Channel);
              serialize: ((value?: Channel) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 3);
              serialize: ((value?: 3) => Buffer);
          }], readonly ["initiator", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["responder", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["channelAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["initiatorAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["responderAmount", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["channelReserve", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["initiatorDelegateIds", {
              deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
              serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
          }], readonly ["responderDelegateIds", {
              deserialize: ((value: Buffer[]) => (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]);
              serialize: ((value: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[]) => Buffer[]);
          }], readonly ["stateHash", hex], readonly ["round", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["soloRound", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["lockPeriod", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["lockedUntil", {
              deserialize(value: Buffer): string;
              serialize(value: Int): Buffer;
          }], readonly ["initiatorAuth", binary, ContractBytearray], readonly ["responderAuth", binary, ContractBytearray]];
      };
      59: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelSnapshotSoloTx);
              serialize: ((value?: ChannelSnapshotSoloTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channelId", {
              deserialize: ((value: Buffer) => `ch_${string}`);
              serialize: ((value: `ch_${string}`) => Buffer);
          }], readonly ["fromId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["payload", binary, Transaction], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }]];
      };
      60: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => TreesPoi);
              serialize: ((value?: TreesPoi) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accounts", {
              deserialize: ((value: MPTreeBinary[], o: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }) => MPTree<AccountAddress, Account>[]);
              serialize: ((value: MPTree<AccountAddress, Account>[]) => MPTreeBinary[]);
          }], readonly ["calls", {
              deserialize: ((value: MPTreeBinary[], o: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }) => MPTree<Bytearray, ContractCall>[]);
              serialize: ((value: MPTree<Bytearray, ContractCall>[]) => MPTreeBinary[]);
          }], readonly ["channels", {
              deserialize: ((value: MPTreeBinary[], o: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }) => MPTree<Channel, Channel>[]);
              serialize: ((value: MPTree<Channel, Channel>[]) => MPTreeBinary[]);
          }], readonly ["contracts", {
              deserialize: ((value: MPTreeBinary[], o: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }) => MPTree<ContractAddress, Contract>[]);
              serialize: ((value: MPTree<ContractAddress, Contract>[]) => MPTreeBinary[]);
          }], readonly ["ns", {
              deserialize: ((value: MPTreeBinary[], o: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }) => MPTree<Name, Name>[]);
              serialize: ((value: MPTree<Name, Name>[]) => MPTreeBinary[]);
          }], readonly ["oracles", {
              deserialize: ((value: MPTreeBinary[], o: {
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }) => MPTree<OracleAddress, Oracle>[]);
              serialize: ((value: MPTree<OracleAddress, Oracle>[]) => MPTreeBinary[]);
          }]];
      };
      62: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => StateTrees);
              serialize: ((value?: StateTrees) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["contracts", rlpBinary], readonly ["calls", rlpBinary], readonly ["channels", rlpBinary], readonly ["ns", rlpBinary], readonly ["oracles", rlpBinary], readonly ["accounts", rlpBinary]];
      };
      621: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ContractsMtree);
              serialize: ((value?: ContractsMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["contracts", rlpBinary]];
      };
      622: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => CallsMtree);
              serialize: ((value?: CallsMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["calls", rlpBinary]];
      };
      623: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => ChannelsMtree);
              serialize: ((value?: ChannelsMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["channels", rlpBinary]];
      };
      624: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => NameserviceMtree);
              serialize: ((value?: NameserviceMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["mtree", rlpBinary]];
      };
      625: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => OraclesMtree);
              serialize: ((value?: OraclesMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["otree", rlpBinary]];
      };
      626: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => AccountsMtree);
              serialize: ((value?: AccountsMtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["accounts", rlpBinary]];
      };
      63: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => Mtree);
              serialize: ((value?: Mtree) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["values", rlpBinaries]];
      };
      64: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => MtreeValue);
              serialize: ((value?: MtreeValue) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["key", hex], readonly ["value", rawBinary]];
      };
      70: {
          3: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => CompilerSophia);
              serialize: ((value?: CompilerSophia) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 3);
              serialize: ((value?: 3) => Buffer);
          }], readonly ["sourceCodeHash", rawBinary], readonly ["typeInfo", sophiaCodeTypeInfo], readonly ["byteCode", rawBinary], readonly ["compilerVersion", string], readonly ["payable", bool]];
      };
      80: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => GaAttachTx);
              serialize: ((value?: GaAttachTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["ownerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["code", binary, ContractBytearray], readonly ["authFun", rawBinary], readonly ["ctVersion", ctVersion], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["ttl", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): Buffer;
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["callData", binary, ContractBytearray]];
      };
      81: {
          2: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => GaMetaTx);
              serialize: ((value?: GaMetaTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 2);
              serialize: ((value?: 2) => Buffer);
          }], readonly ["gaId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["authData", binary, ContractBytearray], readonly ["abiVersion", {
              deserialize: ((value: Buffer) => ABI_VERSIONS);
              serialize: ((value: ABI_VERSIONS) => Buffer);
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["gasLimit", {
              deserialize(value: Buffer): number;
              serialize(_value: undefined | number, __namedParameters: {
                  _computingGasLimit?: number;
                  gasMax: number;
                  rebuildTx: ((params: any) => any);
                  tag: Tag;
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): Buffer;
          }], readonly ["gasPrice", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(value?: undefined | string): string;
          }], readonly ["tx", rlpBinary]];
      };
      82: {
          1: readonly [readonly ["tag", {
              deserialize: ((value: Buffer) => PayingForTx);
              serialize: ((value?: PayingForTx) => Buffer);
          }], readonly ["version", {
              deserialize: ((value: Buffer) => 1);
              serialize: ((value?: 1) => Buffer);
          }], readonly ["payerId", {
              deserialize: ((value: Buffer) => `ak_${string}`);
              serialize: ((value: `ak_${string}`) => Buffer);
          }], readonly ["nonce", {
              deserialize(value: Buffer): number;
              serialize(value: number): Buffer;
          }], readonly ["fee", {
              deserialize(value: Buffer): string;
              serialize(value: undefined | Int, __namedParameters: Options): Buffer;
              serializeAettos(_value: undefined | string, __namedParameters: {
                  _computingMinFee?: BigNumber;
                  _pickBiggerFee?: boolean;
                  rebuildTx: ((params: any) => `tx_${string}`);
                  unpackTx: (<TxType>(encodedTx: `tx_${string}` | `pi_${string}`, txType?: TxType) => TxUnpacked<TxTypeSchemas[TxType]>);
              }): string;
          }], readonly ["tx", rlpBinary]];
      };
  }[TxType]>, number>>, "version" | "tag"> & (TxType extends ContractCreateTx | ContractCallTx | ChannelOffChainUpdateCallContract | GaAttachTx | GaMetaTx ? {
      gasMax?: number;
  } : {}), "nonce" | "ttl" | "abiVersion" | "tag" | "ctVersion"> & {
      denomination?: AE_AMOUNT_FORMATS;
  } & Omit<{
      absoluteTtl?: boolean;
      onNode: Node;
      senderId: `ak_${string}`;
      strategy?: "max" | "continuity";
  } & Pick<Partial<Partial<Pick<{
      tag: undefined | Account;
  }, "tag">> & Omit<{
      tag: undefined | Account;
  }, "tag"> & Partial<Pick<{
      nonce: number;
  }, never>> & Omit<{
      nonce: number;
  }, never> & Partial<Pick<{
      balance: Int;
  }, never>> & Omit<{
      balance: Int;
  }, never> & Partial<Pick<{
      version: undefined | 2;
  }, "version">> & Omit<{
      version: undefined | 2;
  }, "version"> & Partial<Pick<{
      flags: Int;
  }, never>> & Omit<{
      flags: Int;
  }, never> & Partial<Pick<{
      gaContract: `ct_${string}` | `nm_${string}`;
  }, never>> & Omit<{
      gaContract: `ct_${string}` | `nm_${string}`;
  }, never> & Partial<Pick<{
      gaAuthFun: `cb_${string}`;
  }, never>> & Omit<{
      gaAuthFun: `cb_${string}`;
  }, never> & Partial<Pick<{
      version: undefined | 1;
  }, "version">> & Omit<{
      version: undefined | 1;
  }, "version"> & Partial<Pick<{
      tag: undefined | SignedTx;
  }, "tag">> & Omit<{
      tag: undefined | SignedTx;
  }, "tag"> & Partial<Pick<{
      signatures: Uint8Array[];
  }, never>> & Omit<{
      signatures: Uint8Array[];
  }, never> & Partial<Pick<{
      encodedTx: any;
  }, "encodedTx">> & Omit<{
      encodedTx: any;
  }, "encodedTx"> & Partial<Pick<{
      tag: undefined | SpendTx;
  }, "tag">> & Omit<{
      tag: undefined | SpendTx;
  }, "tag"> & Partial<Pick<{
      senderId: `ak_${string}`;
  }, never>> & Omit<{
      senderId: `ak_${string}`;
  }, never> & Partial<Pick<{
      recipientId: `ak_${string}` | `nm_${string}`;
  }, never>> & Omit<{
      recipientId: `ak_${string}` | `nm_${string}`;
  }, never> & Partial<Pick<{
      amount: undefined | Int;
  }, "amount">> & Omit<{
      amount: undefined | Int;
  }, "amount"> & Partial<Pick<{
      fee: undefined | Int;
  }, "fee">> & Omit<{
      fee: undefined | Int;
  }, "fee"> & Partial<Pick<{
      ttl: number;
  }, never>> & Omit<{
      ttl: number;
  }, never> & Partial<Pick<{
      payload: undefined | string;
  }, "payload">> & Omit<{
      payload: undefined | string;
  }, "payload"> & Partial<Pick<{
      accountId: `ak_${string}`;
  }, never>> & Omit<{
      accountId: `ak_${string}`;
  }, never> & Partial<Pick<{
      abiVersion: ABI_VERSIONS;
  }, never>> & Omit<{
      abiVersion: ABI_VERSIONS;
  }, never> & Partial<Pick<{
      tag: undefined | Oracle;
  }, "tag">> & Omit<{
      tag: undefined | Oracle;
  }, "tag"> & Partial<Pick<{
      queryFormat: string;
  }, never>> & Omit<{
      queryFormat: string;
  }, never> & Partial<Pick<{
      responseFormat: string;
  }, never>> & Omit<{
      responseFormat: string;
  }, never> & Partial<Pick<{
      queryFee: undefined | Int;
  }, "queryFee">> & Omit<{
      queryFee: undefined | Int;
  }, "queryFee"> & Partial<Pick<{
      oracleTtlValue: number;
  }, never>> & Omit<{
      oracleTtlValue: number;
  }, never> & Partial<Pick<{
      tag: undefined | OracleRegisterTx;
  }, "tag">> & Omit<{
      tag: undefined | OracleRegisterTx;
  }, "tag"> & Partial<Pick<{
      oracleTtlType: ORACLE_TTL_TYPES;
  }, never>> & Omit<{
      oracleTtlType: ORACLE_TTL_TYPES;
  }, never> & Partial<Pick<{
      oracleId: `ok_${string}` | `nm_${string}`;
  }, never>> & Omit<{
      oracleId: `ok_${string}` | `nm_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | OracleQueryTx;
  }, "tag">> & Omit<{
      tag: undefined | OracleQueryTx;
  }, "tag"> & Partial<Pick<{
      query: string;
  }, never>> & Omit<{
      query: string;
  }, never> & Partial<Pick<{
      queryTtlType: ORACLE_TTL_TYPES;
  }, never>> & Omit<{
      queryTtlType: ORACLE_TTL_TYPES;
  }, never> & Partial<Pick<{
      queryTtlValue: number;
  }, never>> & Omit<{
      queryTtlValue: number;
  }, never> & Partial<Pick<{
      responseTtlType: ORACLE_TTL_TYPES;
  }, never>> & Omit<{
      responseTtlType: ORACLE_TTL_TYPES;
  }, never> & Partial<Pick<{
      responseTtlValue: number;
  }, never>> & Omit<{
      responseTtlValue: number;
  }, never> & Partial<Pick<{
      tag: undefined | OracleResponseTx;
  }, "tag">> & Omit<{
      tag: undefined | OracleResponseTx;
  }, "tag"> & Partial<Pick<{
      oracleId: `ok_${string}`;
  }, never>> & Omit<{
      oracleId: `ok_${string}`;
  }, never> & Partial<Pick<{
      queryId: `oq_${string}`;
  }, never>> & Omit<{
      queryId: `oq_${string}`;
  }, never> & Partial<Pick<{
      response: string;
  }, never>> & Omit<{
      response: string;
  }, never> & Partial<Pick<{
      tag: undefined | OracleExtendTx;
  }, "tag">> & Omit<{
      tag: undefined | OracleExtendTx;
  }, "tag"> & Partial<Pick<{
      tag: undefined | Name;
  }, "tag">> & Omit<{
      tag: undefined | Name;
  }, "tag"> & Partial<Pick<{
      nameTtl: number;
  }, never>> & Omit<{
      nameTtl: number;
  }, never> & Partial<Pick<{
      status: `${any}_${string}`;
  }, never>> & Omit<{
      status: `${any}_${string}`;
  }, never> & Partial<Pick<{
      clientTtl: number;
  }, never>> & Omit<{
      clientTtl: number;
  }, never> & Partial<Pick<{
      pointers: NamePointer[];
  }, never>> & Omit<{
      pointers: NamePointer[];
  }, never> & Partial<Pick<{
      tag: undefined | NameClaimTx;
  }, "tag">> & Omit<{
      tag: undefined | NameClaimTx;
  }, "tag"> & Partial<Pick<{
      name: `${string}.chain`;
  }, never>> & Omit<{
      name: `${string}.chain`;
  }, never> & Partial<Pick<{
      nameSalt: Int;
  }, never>> & Omit<{
      nameSalt: Int;
  }, never> & Partial<Pick<{
      nameFee: undefined | Int;
  }, "nameFee">> & Omit<{
      nameFee: undefined | Int;
  }, "nameFee"> & Partial<Pick<{
      tag: undefined | NamePreclaimTx;
  }, "tag">> & Omit<{
      tag: undefined | NamePreclaimTx;
  }, "tag"> & Partial<Pick<{
      commitmentId: `cm_${string}`;
  }, never>> & Omit<{
      commitmentId: `cm_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | NameUpdateTx;
  }, "tag">> & Omit<{
      tag: undefined | NameUpdateTx;
  }, "tag"> & Partial<Pick<{
      nameId: `${string}.chain` | `nm_${string}`;
  }, never>> & Omit<{
      nameId: `${string}.chain` | `nm_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | NameRevokeTx;
  }, "tag">> & Omit<{
      tag: undefined | NameRevokeTx;
  }, "tag"> & Partial<Pick<{
      tag: undefined | NameTransferTx;
  }, "tag">> & Omit<{
      tag: undefined | NameTransferTx;
  }, "tag"> & Partial<Pick<{
      tag: undefined | Contract;
  }, "tag">> & Omit<{
      tag: undefined | Contract;
  }, "tag"> & Partial<Pick<{
      owner: `ak_${string}`;
  }, never>> & Omit<{
      owner: `ak_${string}`;
  }, never> & Partial<Pick<{
      ctVersion: CtVersion;
  }, never>> & Omit<{
      ctVersion: CtVersion;
  }, never> & Partial<Pick<{
      code: `cb_${string}`;
  }, never>> & Omit<{
      code: `cb_${string}`;
  }, never> & Partial<Pick<{
      log: `cb_${string}`;
  }, never>> & Omit<{
      log: `cb_${string}`;
  }, never> & Partial<Pick<{
      active: Boolean;
  }, never>> & Omit<{
      active: Boolean;
  }, never> & Partial<Pick<{
      referers: `ak_${string}`[];
  }, never>> & Omit<{
      referers: `ak_${string}`[];
  }, never> & Partial<Pick<{
      deposit: undefined | Int;
  }, "deposit">> & Omit<{
      deposit: undefined | Int;
  }, "deposit"> & Partial<Pick<{
      gasPrice: undefined | Int;
  }, "gasPrice">> & Omit<{
      gasPrice: undefined | Int;
  }, "gasPrice"> & Partial<Pick<{
      callerId: `ak_${string}`;
  }, never>> & Omit<{
      callerId: `ak_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | ContractCall;
  }, "tag">> & Omit<{
      tag: undefined | ContractCall;
  }, "tag"> & Partial<Pick<{
      callerNonce: number;
  }, never>> & Omit<{
      callerNonce: number;
  }, never> & Partial<Pick<{
      height: number;
  }, never>> & Omit<{
      height: number;
  }, never> & Partial<Pick<{
      contractId: `ct_${string}`;
  }, never>> & Omit<{
      contractId: `ct_${string}`;
  }, never> & Partial<Pick<{
      gasUsed: number;
  }, never>> & Omit<{
      gasUsed: number;
  }, never> & Partial<Pick<{
      returnValue: `cb_${string}`;
  }, never>> & Omit<{
      returnValue: `cb_${string}`;
  }, never> & Partial<Pick<{
      returnType: CallReturnType;
  }, never>> & Omit<{
      returnType: CallReturnType;
  }, never> & Partial<Pick<{
      log: Uint8Array;
  }, never>> & Omit<{
      log: Uint8Array;
  }, never> & Partial<Pick<{
      tag: undefined | ContractCreateTx;
  }, "tag">> & Omit<{
      tag: undefined | ContractCreateTx;
  }, "tag"> & Partial<Pick<{
      ownerId: `ak_${string}`;
  }, never>> & Omit<{
      ownerId: `ak_${string}`;
  }, never> & Partial<Pick<{
      gasLimit: undefined | number;
  }, "gasLimit">> & Omit<{
      gasLimit: undefined | number;
  }, "gasLimit"> & Partial<Pick<{
      callData: `cb_${string}`;
  }, never>> & Omit<{
      callData: `cb_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | ContractCallTx;
  }, "tag">> & Omit<{
      tag: undefined | ContractCallTx;
  }, "tag"> & Partial<Pick<{
      contractId: `ct_${string}` | `nm_${string}`;
  }, never>> & Omit<{
      contractId: `ct_${string}` | `nm_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | ChannelCreateTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelCreateTx;
  }, "tag"> & Partial<Pick<{
      initiator: `ak_${string}`;
  }, never>> & Omit<{
      initiator: `ak_${string}`;
  }, never> & Partial<Pick<{
      initiatorAmount: Int;
  }, never>> & Omit<{
      initiatorAmount: Int;
  }, never> & Partial<Pick<{
      responder: `ak_${string}`;
  }, never>> & Omit<{
      responder: `ak_${string}`;
  }, never> & Partial<Pick<{
      responderAmount: Int;
  }, never>> & Omit<{
      responderAmount: Int;
  }, never> & Partial<Pick<{
      channelReserve: Int;
  }, never>> & Omit<{
      channelReserve: Int;
  }, never> & Partial<Pick<{
      lockPeriod: Int;
  }, never>> & Omit<{
      lockPeriod: Int;
  }, never> & Partial<Pick<{
      initiatorDelegateIds: string;
  }, never>> & Omit<{
      initiatorDelegateIds: string;
  }, never> & Partial<Pick<{
      responderDelegateIds: string;
  }, never>> & Omit<{
      responderDelegateIds: string;
  }, never> & Partial<Pick<{
      stateHash: `st_${string}`;
  }, never>> & Omit<{
      stateHash: `st_${string}`;
  }, never> & Partial<Pick<{
      channelId: `ch_${string}`;
  }, never>> & Omit<{
      channelId: `ch_${string}`;
  }, never> & Partial<Pick<{
      fromId: `ak_${string}`;
  }, never>> & Omit<{
      fromId: `ak_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | ChannelDepositTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelDepositTx;
  }, "tag"> & Partial<Pick<{
      amount: Int;
  }, never>> & Omit<{
      amount: Int;
  }, never> & Partial<Pick<{
      round: number;
  }, never>> & Omit<{
      round: number;
  }, never> & Partial<Pick<{
      tag: undefined | ChannelWithdrawTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelWithdrawTx;
  }, "tag"> & Partial<Pick<{
      toId: `ak_${string}`;
  }, never>> & Omit<{
      toId: `ak_${string}`;
  }, never> & Partial<Pick<{
      payload: `tx_${string}`;
  }, never>> & Omit<{
      payload: `tx_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | ChannelForceProgressTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelForceProgressTx;
  }, "tag"> & Partial<Pick<{
      update: `cb_${string}`;
  }, never>> & Omit<{
      update: `cb_${string}`;
  }, never> & Partial<Pick<{
      offChainTrees: any;
  }, "offChainTrees">> & Omit<{
      offChainTrees: any;
  }, "offChainTrees"> & Partial<Pick<{
      tag: undefined | ChannelCloseMutualTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelCloseMutualTx;
  }, "tag"> & Partial<Pick<{
      initiatorAmountFinal: Int;
  }, never>> & Omit<{
      initiatorAmountFinal: Int;
  }, never> & Partial<Pick<{
      responderAmountFinal: Int;
  }, never>> & Omit<{
      responderAmountFinal: Int;
  }, never> & Partial<Pick<{
      tag: undefined | TreesPoi;
  }, "tag">> & Omit<{
      tag: undefined | TreesPoi;
  }, "tag"> & Partial<Pick<{
      accounts: MPTree<AccountAddress, Account>[];
  }, never>> & Omit<{
      accounts: MPTree<AccountAddress, Account>[];
  }, never> & Partial<Pick<{
      calls: MPTree<Bytearray, ContractCall>[];
  }, never>> & Omit<{
      calls: MPTree<Bytearray, ContractCall>[];
  }, never> & Partial<Pick<{
      channels: MPTree<Channel, Channel>[];
  }, never>> & Omit<{
      channels: MPTree<Channel, Channel>[];
  }, never> & Partial<Pick<{
      contracts: MPTree<ContractAddress, Contract>[];
  }, never>> & Omit<{
      contracts: MPTree<ContractAddress, Contract>[];
  }, never> & Partial<Pick<{
      ns: MPTree<Name, Name>[];
  }, never>> & Omit<{
      ns: MPTree<Name, Name>[];
  }, never> & Partial<Pick<{
      oracles: MPTree<OracleAddress, Oracle>[];
  }, never>> & Omit<{
      oracles: MPTree<OracleAddress, Oracle>[];
  }, never> & Partial<Pick<{
      tag: undefined | ChannelCloseSoloTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelCloseSoloTx;
  }, "tag"> & Partial<Pick<{
      poi: {
          tag: TreesPoi;
          version?: 1;
      } & Omit<Partial<Pick<({ version: 1 | undefined; }), "version">> & Omit<({ version: 1 | undefined; }), "version"> & Partial<Pick<({ tag: Tag.TreesPoi | undefined; }), "tag">> & Omit<({ tag: Tag.TreesPoi | undefined; }), "tag"> & Partial<Pick<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never>> & Omit<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never> & Partial<Pick<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never>> & Omit<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never> & Partial<Pick<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never>> & Omit<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never> & Partial<Pick<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never>> & Omit<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never> & Partial<Pick<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never>> & Omit<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never> & Partial<Pick<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>> & Omit<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>, "version" | "tag">;
  }, never>> & Omit<{
      poi: {
          tag: TreesPoi;
          version?: 1;
      } & Omit<Partial<Pick<({ version: 1 | undefined; }), "version">> & Omit<({ version: 1 | undefined; }), "version"> & Partial<Pick<({ tag: Tag.TreesPoi | undefined; }), "tag">> & Omit<({ tag: Tag.TreesPoi | undefined; }), "tag"> & Partial<Pick<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never>> & Omit<({ accounts: MPTree<Encoding.AccountAddress, Tag.Account>[]; }), never> & Partial<Pick<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never>> & Omit<({ calls: MPTree<Encoding.Bytearray, Tag.ContractCall>[]; }), never> & Partial<Pick<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never>> & Omit<({ channels: MPTree<Encoding.Channel, Tag.Channel>[]; }), never> & Partial<Pick<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never>> & Omit<({ contracts: MPTree<Encoding.ContractAddress, Tag.Contract>[]; }), never> & Partial<Pick<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never>> & Omit<({ ns: MPTree<Encoding.Name, Tag.Name>[]; }), never> & Partial<Pick<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>> & Omit<({ oracles: MPTree<Encoding.OracleAddress, Tag.Oracle>[]; }), never>, "version" | "tag">;
  }, never> & Partial<Pick<{
      tag: undefined | ChannelSlashTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelSlashTx;
  }, "tag"> & Partial<Pick<{
      tag: undefined | ChannelSettleTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelSettleTx;
  }, "tag"> & Partial<Pick<{
      tag: undefined | ChannelOffChainTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelOffChainTx;
  }, "tag"> & Partial<Pick<{
      tag: undefined | ChannelOffChainUpdateTransfer;
  }, "tag">> & Omit<{
      tag: undefined | ChannelOffChainUpdateTransfer;
  }, "tag"> & Partial<Pick<{
      from: `ak_${string}`;
  }, never>> & Omit<{
      from: `ak_${string}`;
  }, never> & Partial<Pick<{
      to: `ak_${string}`;
  }, never>> & Omit<{
      to: `ak_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | ChannelOffChainUpdateDeposit;
  }, "tag">> & Omit<{
      tag: undefined | ChannelOffChainUpdateDeposit;
  }, "tag"> & Partial<Pick<{
      tag: undefined | ChannelOffChainUpdateWithdraw;
  }, "tag">> & Omit<{
      tag: undefined | ChannelOffChainUpdateWithdraw;
  }, "tag"> & Partial<Pick<{
      tag: undefined | ChannelOffChainUpdateCreateContract;
  }, "tag">> & Omit<{
      tag: undefined | ChannelOffChainUpdateCreateContract;
  }, "tag"> & Partial<Pick<{
      deposit: Int;
  }, never>> & Omit<{
      deposit: Int;
  }, never> & Partial<Pick<{
      tag: undefined | ChannelOffChainUpdateCallContract;
  }, "tag">> & Omit<{
      tag: undefined | ChannelOffChainUpdateCallContract;
  }, "tag"> & Partial<Pick<{
      caller: `ak_${string}`;
  }, never>> & Omit<{
      caller: `ak_${string}`;
  }, never> & Partial<Pick<{
      contract: `ct_${string}`;
  }, never>> & Omit<{
      contract: `ct_${string}`;
  }, never> & Partial<Pick<{
      callStack: any;
  }, "callStack">> & Omit<{
      callStack: any;
  }, "callStack"> & Partial<Pick<{
      tag: undefined | ChannelClientReconnectTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelClientReconnectTx;
  }, "tag"> & Partial<Pick<{
      role: string;
  }, never>> & Omit<{
      role: string;
  }, never> & Partial<Pick<{
      pubkey: `ak_${string}`;
  }, never>> & Omit<{
      pubkey: `ak_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | Channel;
  }, "tag">> & Omit<{
      tag: undefined | Channel;
  }, "tag"> & Partial<Pick<{
      version: undefined | 3;
  }, "version">> & Omit<{
      version: undefined | 3;
  }, "version"> & Partial<Pick<{
      channelAmount: Int;
  }, never>> & Omit<{
      channelAmount: Int;
  }, never> & Partial<Pick<{
      initiatorDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
  }, never>> & Omit<{
      initiatorDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
  }, never> & Partial<Pick<{
      responderDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
  }, never>> & Omit<{
      responderDelegateIds: (`ch_${string}` | `ct_${string}` | `ok_${string}` | `ak_${string}` | `cm_${string}` | `nm_${string}`)[];
  }, never> & Partial<Pick<{
      stateHash: string;
  }, never>> & Omit<{
      stateHash: string;
  }, never> & Partial<Pick<{
      soloRound: Int;
  }, never>> & Omit<{
      soloRound: Int;
  }, never> & Partial<Pick<{
      lockedUntil: Int;
  }, never>> & Omit<{
      lockedUntil: Int;
  }, never> & Partial<Pick<{
      initiatorAuth: `cb_${string}`;
  }, never>> & Omit<{
      initiatorAuth: `cb_${string}`;
  }, never> & Partial<Pick<{
      responderAuth: `cb_${string}`;
  }, never>> & Omit<{
      responderAuth: `cb_${string}`;
  }, never> & Partial<Pick<{
      tag: undefined | ChannelSnapshotSoloTx;
  }, "tag">> & Omit<{
      tag: undefined | ChannelSnapshotSoloTx;
  }, "tag"> & Partial<Pick<{
      tag: undefined | StateTrees;
  }, "tag">> & Omit<{
      tag: undefined | StateTrees;
  }, "tag"> & Partial<Pick<{
      contracts: any;
  }, "contracts">> & Omit<{
      contracts: any;
  }, "contracts"> & Partial<Pick<{
      calls: any;
  }, "calls">> & Omit<{
      calls: any;
  }, "calls"> & Partial<Pick<{
      channels: any;
  }, "channels">> & Omit<{
      channels: any;
  }, "channels"> & Partial<Pick<{
      ns: any;
  }, "ns">> & Omit<{
      ns: any;
  }, "ns"> & Partial<Pick<{
      oracles: any;
  }, "oracles">> & Omit<{
      oracles: any;
  }, "oracles"> & Partial<Pick<{
      accounts: any;
  }, "accounts">> & Omit<{
      accounts: any;
  }, "accounts"> & Partial<Pick<{
      tag: undefined | Mtree;
  }, "tag">> & Omit<{
      tag: undefined | Mtree;
  }, "tag"> & Partial<Pick<{
      values: any[];
  }, never>> & Omit<{
      values: any[];
  }, never> & Partial<Pick<{
      tag: undefined | MtreeValue;
  }, "tag">> & Omit<{
      tag: undefined | MtreeValue;
  }, "tag"> & Partial<Pick<{
      key: string;
  }, never>> & Omit<{
      key: string;
  }, never> & Partial<Pick<{
      value: Uint8Array;
  }, never>> & Omit<{
      value: Uint8Array;
  }, never> & Partial<Pick<{
      tag: undefined | ContractsMtree;
  }, "tag">> & Omit<{
      tag: undefined | ContractsMtree;
  }, "tag"> & Partial<Pick<{
      tag: undefined | CallsMtree;
  }, "tag">> & Omit<{
      tag: undefined | CallsMtree;
  }, "tag"> & Partial<Pick<{
      tag: undefined | ChannelsMtree;
  }, "tag">> & Omit<{
      tag: undefined | ChannelsMtree;
  }, "tag"> & Partial<Pick<{
      tag: undefined | NameserviceMtree;
  }, "tag">> & Omit<{
      tag: undefined | NameserviceMtree;
  }, "tag"> & Partial<Pick<{
      mtree: any;
  }, "mtree">> & Omit<{
      mtree: any;
  }, "mtree"> & Partial<Pick<{
      tag: undefined | OraclesMtree;
  }, "tag">> & Omit<{
      tag: undefined | OraclesMtree;
  }, "tag"> & Partial<Pick<{
      otree: any;
  }, "otree">> & Omit<{
      otree: any;
  }, "otree"> & Partial<Pick<{
      tag: undefined | AccountsMtree;
  }, "tag">> & Omit<{
      tag: undefined | AccountsMtree;
  }, "tag"> & Partial<Pick<{
      tag: undefined | CompilerSophia;
  }, "tag">> & Omit<{
      tag: undefined | CompilerSophia;
  }, "tag"> & Partial<Pick<{
      sourceCodeHash: Uint8Array;
  }, never>> & Omit<{
      sourceCodeHash: Uint8Array;
  }, never> & Partial<Pick<{
      typeInfo: any;
  }, "typeInfo">> & Omit<{
      typeInfo: any;
  }, "typeInfo"> & Partial<Pick<{
      byteCode: Uint8Array;
  }, never>> & Omit<{
      byteCode: Uint8Array;
  }, never> & Partial<Pick<{
      compilerVersion: string;
  }, never>> & Omit<{
      compilerVersion: string;
  }, never> & Partial<Pick<{
      payable: Boolean;
  }, never>> & Omit<{
      payable: Boolean;
  }, never> & Partial<Pick<{
      tag: undefined | GaAttachTx;
  }, "tag">> & Omit<{
      tag: undefined | GaAttachTx;
  }, "tag"> & Partial<Pick<{
      authFun: Uint8Array;
  }, never>> & Omit<{
      authFun: Uint8Array;
  }, never> & Partial<Pick<{
      tag: undefined | GaMetaTx;
  }, "tag">> & Omit<{
      tag: undefined | GaMetaTx;
  }, "tag"> & Partial<Pick<{
      gaId: `ak_${string}`;
  }, never>> & Omit<{
      gaId: `ak_${string}`;
  }, never> & Partial<Pick<{
      authData: `cb_${string}`;
  }, never>> & Omit<{
      authData: `cb_${string}`;
  }, never> & Partial<Pick<{
      tx: any;
  }, "tx">> & Omit<{
      tx: any;
  }, "tx"> & Partial<Pick<{
      tag: undefined | PayingForTx;
  }, "tag">> & Omit<{
      tag: undefined | PayingForTx;
  }, "tag"> & Partial<Pick<{
      payerId: `ak_${string}`;
  }, never>> & Omit<{
      payerId: `ak_${string}`;
  }, never>>, "nonce" | "ttl">, "senderId"> & (TxType extends OracleResponseTx | OracleExtendTx ? {
      callerId: `ak_${string}`;
  } : {}) & (TxType extends ContractCreateTx | GaAttachTx ? {
      ctVersion?: CtVersion;
  } : {}) & (TxType extends OracleRegisterTx | ContractCallTx ? {
      abiVersion?: ABI_VERSIONS;
  } : {}), "onNode"> & {
      onNode?: Node;
  }
Returns Promise<`tx_${string}`>
Inherited from AeSdkMethods.buildTx
- Defined in AeSdkMethods.ts:103

`Protected` ensureNodeConnected

ensureNodeConnected(): asserts this is AeSdkBase & {
selectedNodeName: string;
}
Returns asserts this is AeSdkBase & {
selectedNodeName: string;
}
- Defined in AeSdkBase.ts:90

getNodeInfo

getNodeInfo(): Promise<NodeInfo>
Get information about node

Example
```
nodePool.getNodeInfo() // { name, version, networkId, protocol, ... }
```
Returns Promise<NodeInfo>
- Defined in AeSdkBase.ts:103

getNodesInPool

getNodesInPool(): Promise<NodeInfo[]>
Get array of available nodes

Example
```
nodePool.getNodesInPool()
```
Returns Promise<NodeInfo[]>
- Defined in AeSdkBase.ts:116

initializeContract

initializeContract<Methods>(options?: Omit<Omit<{
    aci: Aci;
    address?: `ct_${string}`;
    bytecode?: `cb_${string}`;
    fileSystem?: Record<string, string>;
    onCompiler?: CompilerBase;
    onNode: Node;
    sourceCode?: string;
    sourceCodePath?: string;
} & Partial<BuildTxOptions<ContractCallTx, "callData" | "callerId" | "contractId">> & {
    omitUnknown?: boolean;
} & {
    contractAddressToName?: {
        [key: ContractAddress]: string;
    };
} & Omit<SendOptions, "onNode" | "onAccount"> & Omit<{
    combine?: boolean;
    onNode: Node;
    top?: number | `kh_${string}` | `mh_${string}`;
    txEvents?: boolean;
}, "onNode"> & {
    callStatic?: boolean;
    onAccount?: AccountBase;
    onNode?: Node;
} & Partial<BuildTxOptions<ContractCreateTx, "code" | "ownerId" | "callData">>, "address" | "aci"> & {
    aci?: Aci;
    address?: `${string}.chain` | `ct_${string}`;
    validateBytecode?: boolean;
}, "onNode"> & {
    onNode?: Node;
}): Promise<Contract<Methods>>
Type Parameters
- Methods extends ContractMethodsBase
Parameters
- Optional options: Omit<Omit<{
      aci: Aci;
      address?: `ct_${string}`;
      bytecode?: `cb_${string}`;
      fileSystem?: Record<string, string>;
      onCompiler?: CompilerBase;
      onNode: Node;
      sourceCode?: string;
      sourceCodePath?: string;
  } & Partial<BuildTxOptions<ContractCallTx, "callData" | "callerId" | "contractId">> & {
      omitUnknown?: boolean;
  } & {
      contractAddressToName?: {
          [key: ContractAddress]: string;
      };
  } & Omit<SendOptions, "onNode" | "onAccount"> & Omit<{
      combine?: boolean;
      onNode: Node;
      top?: number | `kh_${string}` | `mh_${string}`;
      txEvents?: boolean;
  }, "onNode"> & {
      callStatic?: boolean;
      onAccount?: AccountBase;
      onNode?: Node;
  } & Partial<BuildTxOptions<ContractCreateTx, "code" | "ownerId" | "callData">>, "address" | "aci"> & {
      aci?: Aci;
      address?: `${string}.chain` | `ct_${string}`;
      validateBytecode?: boolean;
  }, "onNode"> & {
      onNode?: Node;
  }
Returns Promise<Contract<Methods>>
Inherited from AeSdkMethods.initializeContract
- Defined in AeSdkMethods.ts:114

isNodeConnected

isNodeConnected(): this is AeSdkBase & {
selectedNodeName: string;
}
Check if you have selected node

Example
```
nodePool.isNodeConnected()
```
Returns this is AeSdkBase & {
selectedNodeName: string;
}
- Defined in AeSdkBase.ts:86

selectNode

selectNode(name: string): void
Select Node

Example
```
nodePool.selectNode('testNode')
```
Parameters
- name: string
  
  Node name
Returns void
- Defined in AeSdkBase.ts:76

sign

sign(data: string | Uint8Array, __namedParameters?: {
onAccount?: OnAccount;
}): Promise<Uint8Array>
Parameters
- data: string | Uint8Array
- __namedParameters: {
  onAccount?: OnAccount;
  } = {}
  - Optional onAccount?: OnAccount
Returns Promise<Uint8Array>
- Defined in AeSdkBase.ts:134

signMessage

signMessage(message: string, __namedParameters?: {
    onAccount?: OnAccount;
} & {
    aeppOrigin?: string;
    aeppRpcClientId?: string;
}): Promise<Uint8Array>
Parameters
- message: string
- __namedParameters: {
      onAccount?: OnAccount;
  } & {
      aeppOrigin?: string;
      aeppRpcClientId?: string;
  } = {}
Returns Promise<Uint8Array>
- Defined in AeSdkBase.ts:149

signTransaction

signTransaction(tx: `tx_${string}`, __namedParameters?: {
    onAccount?: OnAccount;
} & {
    aeppOrigin?: string;
    aeppRpcClientId?: string;
    authData?: {
        args?: any[];
        callData?: `cb_${string}`;
        gasLimit?: number;
        sourceCode?: string;
    };
    innerTx?: boolean;
    networkId?: string;
    onCompiler?: CompilerBase;
    onNode?: Node;
}): Promise<`tx_${string}`>
Parameters
- tx: `tx_${string}`
- __namedParameters: {
      onAccount?: OnAccount;
  } & {
      aeppOrigin?: string;
      aeppRpcClientId?: string;
      authData?: {
          args?: any[];
          callData?: `cb_${string}`;
          gasLimit?: number;
          sourceCode?: string;
      };
      innerTx?: boolean;
      networkId?: string;
      onCompiler?: CompilerBase;
      onNode?: Node;
  } = {}
Returns Promise<`tx_${string}`>
- Defined in AeSdkBase.ts:141

Class AeSdkBase

Hierarchy

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Parameters

options: AeSdkMethodsOptions & { nodes?: { instance: Node; name: string; }[]; } = {}

Returns AeSdkBase

Properties

_getPollInterval

Type declaration

Parameters

Rest ...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{ _expectedMineRate?: number; _maxPollInterval?: number; _microBlockCycle?: number; }, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns number

_options

aensBid

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<AensClaimReturnType>

aensClaim

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<AensClaimReturnType>

aensPreclaim

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<Readonly<SendReturnType & { claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>); commitmentId: string; height: number; salt: number; }>>

aensQuery

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{ onNode: Node; } & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

aensRevoke

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<SendReturnType>

aensTransfer

Type declaration

Parameters

Rest ...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<SendReturnType>

aensUpdate

Type declaration

Parameters

Rest ...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<SendReturnType>

awaitHeight

Type declaration

Parameters

Rest ...args: [number] | [number, Omit<{ interval?: number; onNode: Node; } & { _expectedMineRate?: number; _maxPollInterval?: number; _microBlockCycle?: number; }, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<number>

buildAuthTxHash

Type declaration

Parameters

Rest ...args: [`tx_${string}`] | [`tx_${string}`, Omit<{ onNode: Node; }, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<Uint8Array>

createGeneralizedAccount

Type declaration

Parameters

Rest ...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<Readonly<{ gaContractId: `ct_${string}`; owner: `ak_${string}`; rawTx: `tx_${string}`; transaction: `th_${string}`; }>>

extendOracleTtl

Type declaration

Parameters

Rest ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<SendReturnType & GetOracleObjectReturnType>

getAccount

Type declaration

Parameters

Rest ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{ hash?: `kh_${string}` | `mh_${string}`; height?: number; onNode: Node; }, "onNode" | "onAccount" | "onCompiler"> & { onAccount?: OnAccount; onCompiler?: CompilerBase; onNode?: Node; }]

Returns Promise<{ authFun?: string; balance: bigint; contractId?: string; id: string; kind?: AccountKind; nonce: number; payable?: boolean; }>

getBalance

Type declaration

options: AeSdkMethodsOptions & {
nodes?: {
instance: Node;
name: string;
}[];
} = {}

`Rest` ...args: ["block" | "microblock"] | ["block" | "microblock", Omit<{
_expectedMineRate?: number;
_maxPollInterval?: number;
_microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`, nameFee: string | number | BigNumber] | [`${string}.chain`, string | number | BigNumber, Omit<Omit<AensClaimOptions, "nameFee">, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`, salt: number] | [`${string}.chain`, number, Omit<AensClaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensPreclaimOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<Readonly<SendReturnType & {
claim: ((opts?: AensClaimOptions) => Promise<AensClaimReturnType>);
commitmentId: string;
height: number;
salt: number;
}>>

`Rest` ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<{
onNode: Node;
} & AensUpdateOptions & AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`] | [`${string}.chain`, Omit<AensRevokeOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [name: `${string}.chain`, account: `ak_${string}`] | [`${string}.chain`, `ak_${string}`, Omit<AensTransferOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [`${string}.chain`, KeyPointers] | [`${string}.chain`, KeyPointers, Omit<AensUpdateOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [number] | [number, Omit<{
interval?: number;
onNode: Node;
} & {
_expectedMineRate?: number;
_maxPollInterval?: number;
_microBlockCycle?: number;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [`tx_${string}`] | [`tx_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [string, any[]] | [string, any[], Omit<CreateGeneralizedAccountOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<Readonly<{
gaContractId: `ct_${string}`;
owner: `ak_${string}`;
rawTx: `tx_${string}`;
transaction: `th_${string}`;
}>>

`Rest` ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<ExtendOracleTtlOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [`ct_${string}` | `ak_${string}`] | [`ct_${string}` | `ak_${string}`, Omit<{
hash?: `kh_${string}` | `mh_${string}`;
height?: number;
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
authFun?: string;
balance: bigint;
contractId?: string;
id: string;
kind?: AccountKind;
nonce: number;
payable?: boolean;
}>

`Rest` ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
abiVersion: string;
active: boolean;
deposit: bigint;
id: string;
ownerId: string;
referrerIds: string[];
vmVersion: string;
}>

`Rest` ...args: [`ct_${string}`] | [`ct_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
bytecode: `cb_${string}`;
}>

`Rest` ...args: [] | [Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
microBlocks: string[];
}>

`Rest` ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
keyBlock: { hash: string; height: number; prevHash: string; prevKeyHash: string; stateHash: string; miner: string; beneficiary: string; target: string; pow?: string[] | undefined; nonce?: number | undefined; time: number; version: number; info: string; };
microBlocks: string[];
}>

`Rest` ...args: [] | [Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [number | `kh_${string}`] | [number | `kh_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
beneficiary: string;
hash: string;
height: number;
info: string;
miner: string;
nonce?: number;
pow?: string[];
prevHash: string;
prevKeyHash: string;
stateHash: string;
target: string;
time: number;
version: number;
}>

`Rest` ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
hash: string;
height: number;
pofHash: string;
prevHash: string;
prevKeyHash: string;
signature: string;
stateHash: string;
time: number;
txsHash: string;
version: number;
}>

`Rest` ...args: [`mh_${string}`] | [`mh_${string}`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [`${string}.chain`] | [`${string}.chain`, Omit<{
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

Returns Promise<{
id: string;
owner?: string;
pointers: ({ key: string; id: string; })[];
ttl: number;
}>

`Rest` ...args: [oracleId: `ok_${string}`] | [`ok_${string}`, Omit<{
onAccount: AccountBase;
onNode: Node;
}, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]

`Rest` ...args: [transaction: `tx_${string}`] | [`tx_${string}`, Omit<PayForTransactionOptions, "onNode" | "onAccount" | "onCompiler"> & {
onAccount?: OnAccount;
onCompiler?: CompilerBase;
onNode?: Node;
}]